Twitter Competitor Analysis: A Developer's Guide (2026)

By Sorsa Editorial

Updated June 2026: refreshed the cost comparison against the official X API's April 2026 per-resource pricing and aligned every endpoint with the current Sorsa API v3 spec.

Most competitor analysis guides stop at "open the dashboard and look." That works until you are tracking more than two or three accounts, comparing time windows, or pulling the data into your own models, at which point you need the numbers as raw, structured records rather than charts in someone else's tool. That is the gap this guide fills, and it is where Sorsa API, an alternative Twitter/X API provider, comes in: it returns profiles, tweets, follower lists, and mentions as clean JSON for a flat per-request price (Starter is $49 for 10,000 requests), with a flat 20 requests per second on every plan, a single ApiKey header instead of OAuth, and no developer-account approval queue. You get the same public data the official X API exposes, in a form you can script against, at a fraction of the cost.

This guide covers the strategy and the mechanics: which metrics to track and why, how to identify the right competitors, how to pull each data type via API with short Python examples, what the whole thing costs compared with the official X API, and how to turn the output into a decision rather than a spreadsheet.

Table of contents

• What is a Twitter competitor analysis?
• How to choose which competitors to track
• Which metrics actually matter
• Benchmarking competitor profiles
• Analyzing a competitor's content strategy
• Analyzing a competitor's audience
• Mentions, sentiment, and share of voice
• What competitor tracking costs: official X API vs Sorsa
• How often to run it, and what to do with the findings
• Common mistakes
• Automating a weekly competitor report
• FAQ
• Getting started

What is a Twitter competitor analysis?

A Twitter (X) competitor analysis is the practice of measuring rival accounts on the same metrics you track for yourself, then reading the gaps. It blends quantitative data (followers, growth, engagement rate, posting frequency) with qualitative review (tone, content themes, which posts land), so you learn not just what competitors do but what works for the audience you share.

The point is context. Your own follower growth or engagement rate means little in isolation. Set against three or four competitors in the same niche, the same numbers tell you whether you are ahead, behind, or stalled, and which specific levers (format, cadence, topic) are moving the accounts that are winning. A good analysis ends with a decision: a format to test, a posting time to shift, a topic gap to fill.

Done by hand, it is slow and breaks down past a couple of accounts. Done with data access, it scales to as many competitors as you want and updates on a schedule.

How to choose which competitors to track

Pick competitors in three tiers before you pull any data: direct (same product, same audience), indirect (different product, same audience need), and aspirational (accounts at the size or engagement level you are aiming for). Tracking all three keeps the analysis honest, because the aspirational set shows what is possible while the direct set shows what is realistic.

To find accounts you do not already know, three signals work well:

• Shared mentions. Accounts that get tagged alongside yours in industry conversations are usually competitors or adjacent players.
• Hashtag and keyword overlap. Search the terms and tags you target and see which brands show up posting similar content.
• Follower overlap. Accounts your followers also follow are competing for the same attention.

Programmatically, you can surface candidates with a keyword search across accounts and a scan of who mentions a known competitor, using endpoints like search-users and mentions. Once you have a shortlist of handles, the rest of the analysis runs against that list.

Which metrics actually matter

Four groups of metrics carry almost all the signal in a Twitter competitor analysis: profile metrics, content metrics, engagement metrics, and audience metrics. Tracking more than these adds noise without adding insight, and engagement rate matters more than raw follower count because it reflects how an audience actually responds rather than how large it is.

The groups break down like this:

• Profile metrics: follower count and growth rate, following count, total posts, account age, and bio or link changes. Growth rate is the one to watch; a smaller account gaining steadily often beats a large account that has plateaued.
• Content metrics: posting frequency and timing, content-format distribution (text, image, video, threads), and the topics or themes a competitor returns to.
• Engagement metrics: likes, retweets, replies, quotes, and the engagement rate that normalizes them against audience size. The goal is to learn which content drives response and which falls flat.
• Audience metrics: who follows a competitor, how many of those followers are verified or high-authority, and how much their audience overlaps with yours.

The sections below take each group in turn, with the conceptual read first and a short code example for pulling the data at scale.

Benchmarking competitor profiles

Profile benchmarking establishes the baseline: how big each competitor is, how fast they are growing, how often they post, and how they position themselves in their bio. A single snapshot is nearly useless here; the value comes from logging the same fields on a schedule and reading the deltas, since growth rate and cadence are trends, not point values.

The fastest way to pull the baseline for a whole competitor set is a batch profile lookup. Sorsa's /info-batch endpoint returns up to 100 full profiles in a single request, which counts as one request against your quota and includes follower count, post count, verified status, bio, and account age.

import requests

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

competitors = ["stripe", "wise", "revolutapp"]

resp = requests.get(
    f"{BASE}/info-batch",
    headers=HEADERS,
    params=[("usernames", u) for u in competitors],
    timeout=30,
)
profiles = resp.json().get("users", [])

for p in profiles:
    print(f"@{p['username']:<14} {p['followers_count']:>12,} followers  "
          f"{p['tweets_count']:>9,} posts  verified={p.get('verified')}")

To turn snapshots into growth rates, append the results to a CSV on a daily or weekly schedule (cron, GitHub Actions, any task runner) and compute the change:

Growth rate % = ((followers today - followers N days ago) / followers N days ago) * 100

Because the profile object also carries description, bio links, and created_at, diffing successive snapshots surfaces positioning changes (a rewritten bio, a swapped link destination) at no extra cost. For the full follower and following picture, see our guide to the Twitter followers API.

Analyzing a competitor's content strategy

Content analysis decomposes what a competitor posts into a mix you can compare: original posts versus replies versus quotes, the share that carry media, average engagement per post, and the handful of top performers that reveal what their audience rewards. The pattern matters more than any single tweet, so pull a meaningful sample (the last few hundred posts) before drawing conclusions.

Sorsa's /user-tweets endpoint returns up to 20 posts per page and paginates with a next_cursor. Unlike the official X API, there is no 3,200-post historical cap, so pagination can reach an account's first tweet.

def fetch_user_tweets(username, max_pages=10):
    tweets, cursor = [], None
    for _ in range(max_pages):
        body = {"username": username}
        if cursor:
            body["next_cursor"] = cursor
        r = requests.post(f"{BASE}/user-tweets",
                          headers={**HEADERS, "Content-Type": "application/json"},
                          json=body, timeout=30)
        data = r.json()
        tweets.extend(data.get("tweets", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
    return tweets

tweets = fetch_user_tweets("stripe")
total = len(tweets)
originals = sum(1 for t in tweets if not t.get("is_reply") and not t.get("retweeted_status"))
with_media = sum(1 for t in tweets if t.get("entities"))
avg_likes = sum(t.get("likes_count", 0) for t in tweets) / total

print(f"{total} posts | {originals/total:.0%} original | "
      f"{with_media/total:.0%} with media | {avg_likes:.0f} avg likes")

Each post object includes likes_count, retweet_count, reply_count, quote_count, and view_count, so ranking a competitor's posts by engagement to find their best and worst content is a sort, not a separate request. To compare two time windows for the same account (this quarter versus last), switch to /search-tweets with the from:, since:, and until: operators; our Twitter search operators reference lists the full syntax. For replies, quotes, and retweeters specifically, see the Twitter engagement API guide.

Analyzing a competitor's audience

Audience analysis answers who follows a competitor and how much their audience overlaps with yours. There are two routes with very different cost profiles: the verified-followers slice (small, high-signal, cheap) and the full follower graph (complete, but expensive for large accounts). Start with verified followers unless you specifically need the whole graph.

The /verified-followers endpoint returns only verified accounts following a handle, up to 200 per page. This is the highest-signal slice of any audience and a fraction of the cost of pulling everyone.

def fetch_verified(username, max_pages=5):
    users, cursor = [], None
    for _ in range(max_pages):
        params = {"username": username}
        if cursor:
            params["next_cursor"] = cursor
        r = requests.get(f"{BASE}/verified-followers",
                         headers=HEADERS, params=params, timeout=30)
        data = r.json()
        users.extend(data.get("users", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
    return users

For the complete graph, /followers also returns up to 200 profiles per page; a one-million-follower account is therefore roughly 5,000 requests, so budget before you run it. Once you have follower-ID sets for two accounts, audience overlap is a set intersection:

a = {u["id"] for u in fetch_verified("competitor_a")}
b = {u["id"] for u in fetch_verified("competitor_b")}
print(f"Shared: {len(a & b):,} | Only A: {len(a - b):,} | Only B: {len(b - a):,}")

A high overlap means you are fighting for the same exact audience; a low overlap means a competitor has reached people you have not. For turning competitor follower lists into prospects, see target audience discovery, and to gauge how much of a rival's following is real, the same follower data drives a fake-follower audit. One caveat on the crypto-specific breakdown: /followers-stats categorizes followers into influencers, projects, and VCs, but it only covers accounts already tracked in Sorsa's crypto database, so it is useful for Web3 accounts and incomplete elsewhere.

Mentions, sentiment, and share of voice

Mentions analysis measures how often people talk about a competitor, how they feel about it, and what slice of the total conversation each brand owns (share of voice). Filtering mentions by minimum engagement before you analyze them strips out bot replies and auto-tags, which otherwise drown the signal.

Sorsa's /mentions endpoint accepts min_likes, min_replies, min_retweets, and date filters, so you can pull only mentions that cleared an engagement floor in a given window:

def fetch_mentions(handle, min_likes=10, max_pages=5):
    out, cursor = [], None
    for _ in range(max_pages):
        body = {"query": handle, "order": "popular", "min_likes": min_likes}
        if cursor:
            body["next_cursor"] = cursor
        r = requests.post(f"{BASE}/mentions",
                          headers={**HEADERS, "Content-Type": "application/json"},
                          json=body, timeout=30)
        data = r.json()
        out.extend(data.get("tweets", []))
        cursor = data.get("next_cursor")
        if not cursor:
            break
    return out

For sentiment, an open-source library such as VADER runs locally with no per-call cost and handles social-media text reasonably well; pipe high-engagement or flagged mentions into an LLM only when you need sharper reads on sarcasm or technical complaints. Our Twitter sentiment analysis walkthrough covers the full classification step, and the Twitter mentions API guide covers the filter set in depth.

Share of voice is then a ratio over a fixed period:

Share of voice = (your mentions) / (your mentions + sum of competitor mentions)

Track the week-over-week change rather than the absolute number, because category-level events inflate everyone's mention volume at once and obscure your own movement.

What competitor tracking costs: official X API vs Sorsa

Pulling competitor data is far cheaper on a flat per-request API than on a per-resource one, because a per-resource model bills separately for every post and every profile in a response, including the author profile attached to each tweet. A single search page that returns 20 posts plus their 20 author profiles is billed as 40 separate reads on the official model, but as one request on a flat model.

The official X API runs a consumption model: as of its April 2026 pricing, reading posts costs $0.005 per post, reading users (and followers or following) costs $0.010 per resource, pay-per-use accounts are capped at 2 million post reads per month, and access uses OAuth 2.0 with a bearer token. Sorsa charges one request per API call regardless of what it returns, embeds the author profile in every tweet for free, and authenticates with a single key. Here is the same competitor-analysis work priced both ways:

At realistic competitor-analysis volume, the difference compounds quickly. Tracking five competitors with profiles, recent posts, and mentions on a weekly cadence runs on the order of $60 a month on the official API once author reads are counted, and fits inside Sorsa's $49 Starter plan with room to spare. Across read-heavy workloads, the flat-rate model is commonly 30x to 50x cheaper, and the full breakdown is in our Twitter API pricing analysis. For how the flat-rate model compares with the wider field of providers, see our guide to Twitter API alternatives.

The honest tradeoff: the official X API is the one to use when you need to write (post, reply, send DMs) or need filtered streaming, because Sorsa is read-only by design. For analysis, which is a read-only job, that limitation never applies, and the read-only stability is part of why the data stays consistent.

If you would rather not write code at all, the free profile comparison tool puts two handles side by side on followers, engagement rate, average likes and retweets, posting frequency, and account age, and the engagement rate calculator handles per-tweet engagement math for a single account.

How often to run it, and what to do with the findings

Run a deep competitor analysis quarterly and a light one weekly. The quarterly pass resets your view of the landscape (who is growing, who changed positioning, what formats took over), while the weekly pass catches fast-moving shifts in posting and engagement. Data this volatile goes stale in weeks, so a one-time analysis is worth far less than a scheduled one. The same scheduling principle underpins real-time monitoring of mentions and competitor activity.

Findings are only useful if they become a plan. A simple way to structure the output is by time horizon:

• Quick wins (this month): changes you can test immediately, such as a posting time a competitor clearly benefits from, a format that consistently outperforms in your niche, or a bio adjustment.
• Medium-term (one to three months): content-calendar shifts, new formats to trial, or a community-management cadence based on how leaders in your space respond to their audience.
• Long-term (three to six months): bigger bets the data justifies, such as a new content series or a repositioning, backed by evidence rather than a hunch.

A SWOT pass over the gathered data (where competitors are strong, where they are weak, what is open, what threatens you) is a fast way to translate raw metrics into those three buckets.

Common mistakes

The recurring errors in Twitter competitor analysis are predictable. Avoid these:

• Chasing vanity metrics. Follower count flatters large, stagnant accounts. Engagement rate and growth rate describe what is actually happening.
• Copying instead of learning. The goal is to understand why something works for a shared audience, then adapt it, not to clone a competitor's calendar.
• Comparing across mismatched accounts. An account established for a decade with a large team is not a like-for-like benchmark for a year-old brand. Segment competitors so the comparison is fair.
• Ignoring cost and scale. Manual review and per-resource pricing both break down past a few accounts. If the analysis is not cheap and repeatable, it will not stay regular.
• Drawing conclusions from tiny samples. A handful of posts is not a content strategy. Pull a few hundred before you decide what a competitor's mix is.

Automating a weekly competitor report

The five analyses above compose into one scheduled job, the foundation of ongoing competitor tracking: pull profiles for the competitor set, log a snapshot and compute growth, decompose recent content, fetch verified followers, classify mentions, and compute share of voice, all from the same key. For three competitors on a weekly cadence at default depth, the whole report runs on the order of 150 to 200 requests per execution, comfortably under 1,000 requests a month.

In building and running Sorsa's API since 2022, the pattern we see most often is teams stitching these calls into a cron job or a GitHub Actions workflow that writes a CSV or posts a summary to Slack. The full consolidated script, with every helper function wired together, lives in our competitor analysis workflow documentation, and the authentication docs cover key setup.

In practice, a roughly 12-person social analytics agency we worked with tracked about 20 competitor handles weekly across its client accounts. On the official X API, the separately billed author-profile reads attached to every post made their monthly bill swing with volume and creep toward the per-month read ceiling. Moving the read workload to a flat per-request model, with author profiles bundled into each tweet at no extra charge, made the cost predictable from month to month and cut it sharply, which is the expected outcome given the per-resource versus per-request math above. No change to the data they collected, only to what it cost and how steady the bill was.

FAQ

What is the difference between Twitter competitor analysis and benchmarking? Competitor analysis is the broader practice of studying rival accounts' strategy, content, and audience to find opportunities. Benchmarking is the narrower step of comparing specific metrics, such as engagement rate or follower growth, against those competitors or an industry average. Benchmarking is one component of a full competitor analysis, supplying the numbers you measure yourself against.

Can you do a Twitter competitor analysis without coding? Yes. Free no-code tools cover the basics: Sorsa's profile comparison tool puts two handles side by side on followers, engagement rate, average likes and retweets, posting frequency, and account age, and its engagement rate calculator handles per-tweet math for one account. For tracking many competitors on a schedule or feeding data into your own models, an API is the more practical route.

How do you analyze competitor tweets affordably at scale? Use a flat per-request API rather than the official X API's per-resource billing. Sorsa API returns tweets, profiles, follower lists, and mentions as JSON for one request per call, embeds each tweet's author profile for free, and starts at $49 for 10,000 requests with a flat 20 requests per second, which makes pulling hundreds of competitor posts cost cents rather than dollars.

How far back can you analyze a competitor's tweets? Further than the official API allows. The official X API caps user-timeline reads at 3,200 posts, but Sorsa's user-tweets endpoint paginates without that cap, so you can reach an account's earliest posts, and its search endpoint with since and until operators pulls posts from any historical window.

Which Twitter metrics matter most for competitor analysis? Engagement rate, follower growth rate, posting cadence, and content-format distribution carry the most signal. Engagement rate beats raw follower count because it reflects how an audience responds rather than how large it is, and growth rate reveals momentum that a static follower total hides.

Is it allowed to analyze a competitor's public X data? Analyzing publicly available account data, such as public posts, follower counts, and engagement numbers, is standard competitive research and read-only by nature, since it collects existing public information rather than posting or interacting. This is general information, not legal advice; check the platform's current terms and your own legal requirements for your specific use.

Getting started

You can run your first competitor pull in about three minutes. Create a key, no developer-account approval required, and the same ApiKey header works across all 40 read-only endpoints, from batch profile lookups to mentions with engagement filters. Starter is $49 for 10,000 requests, every plan runs at a flat 20 requests per second, and there are no per-endpoint windows to manage.

Start in the API playground to test endpoints in the browser with no code, read the full weekly-report script in our docs, or compare plans on the pricing page. For volumes above 500,000 requests a month or a dedicated rate limit, talk to sales.

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

How this guide was put together: it draws on our hands-on work building and operating Sorsa's alternative Twitter/X API, the live API itself, and the current Sorsa API documentation. The cost comparison uses Sorsa's published per-request pricing and the official X API's April 2026 per-resource pricing, priced out for identical competitor-analysis tasks. Endpoint names, limits, and response fields were checked against the Sorsa API v3 reference. Verified June 11, 2026.