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

Key Takeaway: To check if one Twitter/X account follows another, open the target profile, tap "Followers," and search the list. For bulk or automated checks, use an API like Sorsa API's /check-follow endpoint, which returns a true/false answer in a single request -- no scrolling, no login, no guesswork.

If you have ever tried to figure out whether someone follows you back on Twitter (now X), you know the process is oddly frustrating. The platform does not have a "check follow" button. You either scroll through a follower list hoping to spot a username or rely on the small "Follows you" badge that only appears on your own profile's follower view.

For a one-time check, that manual method works fine. But it falls apart the moment you need to verify follow relationships at any kind of scale -- running a giveaway campaign, auditing partnerships, or building engagement verification into an app. That is where programmatic solutions come in, and where I have spent a significant chunk of the last twelve years building data pipelines around the Twitter/X ecosystem.

At Sorsa API, we have processed millions of follow-check requests for clients running everything from NFT mint verifications to brand ambassador programs. This guide covers every method available in 2026, from the simplest manual check to a Python script that can verify thousands of relationships per hour.

Table of Contents

• Method 1: Check Manually on Twitter/X
• Method 2: Free Follow Checker Tools (Do They Still Work?)
• Method 3: Check Follow Relationships via API
• How to Check Mutual Follows
• Checking Follow Relationships at Scale
• Which Method Should You Use?
• FAQ

Method 1: Check Manually on Twitter/X

The native approach requires no tools, no API keys, and no third-party access. It also does not scale past a handful of checks.

To check if a specific account follows you:

1. Go to your own profile on X (twitter.com or the mobile app).
2. Tap Followers.
3. Use the search bar at the top of the follower list to type the username you are looking for.
4. If they appear in the results, they follow you. If the search returns nothing, they do not.

To check if one account follows another (not your own):

1. Open the profile of the account you want to check followers for.
2. Tap Followers.
3. Search for the second username.

There is one shortcut worth knowing: when you visit someone's profile and they follow you, X displays a small "Follows you" badge next to their name. This only works for checking whether that person follows you -- it does not tell you anything about their relationship with other accounts.

Limitations of the manual method:

The search inside the follower list is unreliable for accounts with large followings. X loads follower lists in chunks, and the client-side search only queries what has already been loaded into your browser. For accounts with millions of followers, you may get incomplete results. There is also no way to check in the other direction (whether you follow them) from the same screen -- you would need to visit their profile separately and look for the "Following" button state.

For a single, quick check? This works. For anything repeated or systematic, keep reading.

Method 2: Free Follow Checker Tools (Do They Still Work?)

If you search Google for "Twitter follow checker," you will find a handful of free web tools that promise to answer the "does A follow B?" question with a simple form. The most visible one is HackTrix Twitter Follow Checker, which has occupied top search positions for years.

Here is the problem: most of these tools no longer work.

I tested the top-ranking free follow checkers in April 2026. HackTrix's tool does not function at all -- submitting usernames returns no result. Other similar single-purpose checkers either fail silently, throw errors, or redirect to unrelated services. This is not surprising. These tools relied on unofficial Twitter API access or scraping methods that broke after X's API changes in 2023 and subsequent authentication lockdowns.

The broader tools like Circleboom and Audiense Connect (formerly Followerwonk's space) do offer follower analysis features, including the ability to see who follows who. But they are full analytics platforms with their own pricing, not simple follow checkers. If all you need is a yes/no answer to "does @alice follow @bob?", signing up for a social media management suite is overkill.

The free tool landscape for this specific task is effectively dead in 2026. The tools that survive are either part of larger paid platforms, or they have pivoted to different features like follower count tracking and fake follower audits.

Method 3: Check Follow Relationships via API

If you need reliable, repeatable follow checks -- whether for a one-off script or a production application -- an API call is the right approach.

The official X API does not have a dedicated follow-check endpoint. You can fetch a user's follower list and search through it, but that requires paginating through potentially millions of records to answer a simple yes/no question. It is slow, expensive, and wasteful.

Sorsa API provides a purpose-built /check-follow endpoint that answers this question in a single request. Send two usernames, get back true or false. Response time is typically under 300ms.

Quick Example (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: does username_2 follow username_1? If follow is true, the second user follows the first. The user_protected field tells you whether the account is private, in which case follow relationships cannot be verified.

Python Example

import requests

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

def check_follow(target: str, possible_follower: str) -> bool:
    """Check if possible_follower follows target. Returns True/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)

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

You can identify users by username, user ID, or profile URL -- whichever is more convenient for your workflow. Full parameter details are in the API reference.

What This Costs

Sorsa API uses flat per-request pricing. One follow check = one request from your quota. On the Pro plan ($199/month for 100,000 requests), that is $0.00199 per check. On Enterprise ($899/month for 500,000 requests), it drops to $0.0018 per check.

For context: verifying follow relationships for a 2,000-person giveaway costs about $4 on the Pro plan. Compare that to the hours of manual checking or the overhead of building and maintaining your own scraping infrastructure.

How to Check Mutual Follows

A common follow-up question: how do I check if two accounts follow each other?

X does not expose mutual follow status directly. Neither does any third-party API in a single call. To determine if two users mutually follow each other, you need two checks:

def check_mutual_follow(user_a: str, user_b: str) -> dict:
    """Check if two users 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 API calls, two requests from your quota. Total cost on Pro: $0.004. Total time: under a second.

Checking Follow Relationships at Scale

This is where the API approach becomes irreplaceable. If you are running a giveaway, verifying an ambassador program, or building a SaaS product that needs follow verification, manual methods and broken free tools are not options.

Real-world example: A Web3 gaming studio I worked with in early 2025 ran a token launch campaign requiring participants to follow their main account, retweet the announcement, and join their X Community. They had 8,400 entries. Before switching to an API-based pipeline, their community manager was spending two full days manually spot-checking entries -- and still only verified about 20% of them. The remaining 80% went unchecked, and post-campaign analysis showed roughly 35% of unverified entries were fraudulent (bot accounts, unfollowed immediately after screenshot).

After integrating Sorsa API's verification endpoints, they verified all 8,400 participants across three tasks (follow, retweet, community membership) in under 90 minutes. The cost was around $50 on the Pro plan. Fraud dropped to near zero because every single entry was programmatically confirmed.

Here is the pattern for batch follow verification:

import time
import csv

def verify_followers_batch(brand: str, usernames: list, output_file: str = "results.csv"):
    """Verify if a list of users 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 20 req/s rate limit

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

# Verify 2,000 giveaway participants
participants = ["user1", "user2", "user3"]  # Load from your participant list
verify_followers_batch("YourBrand", participants)

At Sorsa API's rate limit of 20 requests per second, you can verify roughly 72,000 follow relationships per hour. The rate limit is universal across all plans and can be raised for high-volume needs by contacting contacts@sorsa.io.

For campaigns that require verifying multiple actions (follow + retweet + comment), Sorsa API offers a full suite of verification endpoints: /check-follow, /check-retweet, /check-comment, /check-quoted, and /check-community-member. Each returns a simple boolean result from a single API call.

Which Method Should You Use?

Method	Best for	Speed	Cost	Reliability
Manual (X app)	One-time personal checks	30-60 seconds	Free	Unreliable for large accounts
Free web tools	--	--	Free	Mostly broken in 2026
Sorsa API /check-follow	Automated, bulk, or production use	~300ms per check	$0.0018-$0.0049/check	Consistent, structured JSON

If you are checking whether your friend follows you back, open the X app and look for the "Follows you" badge. If you are building anything that needs to verify follow relationships programmatically -- a campaign, a bot, a dashboard, an analytics tool -- use an API.

FAQ

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

Yes. Checking someone's follower list is a passive, read-only action. Whether you do it manually on X, through a third-party tool, or via API, the other user receives no notification. This applies to all methods described in this guide.

Why do free Twitter follow checker tools not work anymore?

Most free follow checker websites relied on unofficial access to Twitter's API or web scraping techniques. After X overhauled its API pricing and authentication in 2023 and tightened anti-scraping measures throughout 2024-2025, these tools lost access to the data they depended on. The ones that survive have either migrated to paid API access or pivoted to different features entirely.

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

No. The official X API (v2) provides endpoints to list a user's followers or following, but no dedicated endpoint to check a specific follow relationship between two accounts. To answer "does A follow B?" using the official API, you would need to paginate through the entire follower list of account B, which is slow and expensive for accounts with large followings. Third-party APIs like Sorsa API solve this with purpose-built verification endpoints.

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

No API or tool returns mutual follow status in a single call. You need to check both directions separately: does A follow B, and does B follow A. With Sorsa API, this requires two requests to the /check-follow endpoint -- one for each direction. See the mutual follow code example above.

Can I verify follows for a giveaway or campaign automatically?

Yes. This is one of the most common use cases for the /check-follow endpoint. You collect participant usernames, then loop through them with API calls that return true/false for each. At 20 requests per second, you can verify thousands of participants in minutes. For campaigns that require checking multiple actions (follow, retweet, comment), see our campaign verification guide.

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

No. Private accounts hide their follower and following lists from everyone except approved followers. No external tool or API -- including the official X API -- can access follow data for protected accounts. When you query a private account through Sorsa API, the response includes "user_protected": true so your application can handle this case gracefully.

Is there a way to get notified when someone follows or unfollows me?

X does not provide real-time follow/unfollow notifications beyond the basic "X followed you" alert. For systematic tracking, you would need to periodically fetch your follower list via API and compare it against previous snapshots. Sorsa API's /followers endpoint returns up to 200 followers per request, making it practical to build a daily or hourly diff.

How many follow checks can I run per day with Sorsa API?

This depends on your plan. The Starter plan includes 10,000 requests/month, Pro includes 100,000, and Enterprise includes 500,000. Each follow check consumes one request. All plans share the same rate limit of 20 requests per second. For higher volumes, custom plans are available.

---

Getting Started

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

1. Create a Sorsa API account at api.sorsa.io/overview and grab your API key.
2. Test the /check-follow endpoint in the API playground -- no coding required.
3. Integrate into your workflow. Copy the Python or cURL examples above, or check the quickstart guide for setup instructions in other languages.

One request, one answer, under 300 milliseconds. That is all there is to it.

Last updated: April 2026

Disclosure: Sorsa API is our product. We have aimed to present all methods fairly, but recommend testing any solution against your specific requirements.