USE CASE
Twitter API for Influencer Discovery
Updated July 2026
How do you find and vet Twitter (X) influencers with an API?
The Twitter API is a set of REST endpoints that return any public account's profile, posts and follower graph, which is everything creator discovery needs. Work it in two stages. Sourcing collects candidates from category search, name and handle search, the accounts reposting popular posts in your niche, and a rival's follower list. Vetting pulls each candidate's profile and recent timeline and computes engagement rate, reply ratio, posting consistency and topical fit, with a follower sample as a cheap fraud check. TwitterAPIs serves every one of those reads at $0.0008 per call, so sourcing 500 candidates costs about $0.06 and vetting them about $1.20.
How the numbers on this page were produced
Written by Emma, TwitterAPIs developer relations
Costs are call arithmetic against the flat $0.0008 per read call on our published pricing. The engagement-rate floor quoted below is a working heuristic for ranking a candidate set, not a measured industry benchmark, and it is labelled that way wherever it appears because the honest answer is that the right threshold depends on your category. On read yield, per our own billed-call measurement, 18.78 posts came back on an average timeline call across 396,817 read calls between August 13 and 17 2026, so a two-page vetting pull reaches roughly 37 posts per candidate.
What is Twitter (X) influencer discovery?
Twitter (X) influencer discovery is the two-stage process of finding candidate accounts in a niche and then vetting each one before a brand or agency spends outreach time on it. Sourcing casts a wide net (category search, name and handle search, who reposts popular posts in the niche, a rival's follower list) and vetting narrows it, pulling each candidate's profile and recent timeline to score engagement rate, reply ratio, posting consistency and topical fit against the campaign brief.
Follower count alone answers neither stage. A large following with a flat engagement rate is a common fraud pattern (bought or churned followers), while a smaller account with a consistent reply ratio and on-topic posting often converts better per dollar. That is why every source below feeds into the same vetting pull rather than being treated as a ready-to-pitch list on its own.
Six ways to source candidates, none of them a follower count
Sorting a category by follower count returns the same twenty accounts everyone else already pitched. These six sourcing methods return different people, and the last two in particular surface accounts whose influence is not visible in their own follower number.
| Method | How it works | Endpoint | What it is good at |
|---|---|---|---|
| Topic authors | Search your category terms, then collect the accounts posting them | GET /twitter/tweet/advanced_search | Finds people already talking about your subject, unprompted |
| Name and handle search | Query X's People search for names and handles carrying your niche words (it does not match bio text) | GET /twitter/user/search | Fast way to a long candidate list before any vetting |
| Amplifier mining | Pull the accounts that reposted a popular post in your niche | GET /twitter/tweet/retweeters | Surfaces the people who spread ideas rather than only publish them |
| Competitor orbit | Page a rival's follower list and rank by size and activity | GET /twitter/user/followers | Creators already interested in your category, proven by a follow |
| Verified audience | Read the verified accounts following a hub account in your niche | GET /twitter/user/verified_followers | A short high-signal list, useful when you want few good names fast |
| Reply-thread regulars | Collect the accounts consistently replying under category posts | GET /twitter/tweet/replies | Finds engaged voices whose own posting volume undersells them |
Run several and merge on user id. Each method has a different bias, and the accounts that appear in two or three of them are usually the strongest names on the list.
Six vetting checks, cheapest first
| Check | Signal | Reads | What it tells you |
|---|---|---|---|
| Engagement rate | Median engagement on recent posts, divided by follower count | One profile call plus one timeline pull | The single most useful number. Below roughly 0.1 percent, audience size stops meaning much |
| Reply-to-like ratio | Replies compared with likes across recent posts | Same timeline pull | Real communities argue. A high-like, near-zero-reply account is often a passive or bought audience |
| Posting consistency | Gaps between posts over the last several weeks | Same timeline pull | A creator who vanishes for a month is a delivery risk whatever their numbers say |
| Follower quality sample | Account age and activity on a sample of their followers | One follower page plus profile calls on a sample | Cheap fraud check. A sample of 70 is enough to see an obviously purchased audience |
| Topical fit | Share of recent posts that actually mention your category | Same timeline pull | Stops you paying a large general account to reach an audience that does not care |
| Audience overlap | How many of their followers already follow you | Two follower pulls, the expensive check | High overlap means you are paying to reach people you already have |
Run the first five on every candidate, since together they are one profile call and one timeline pull. Save the audience-overlap check for a shortlist, because it is the only one that needs paged follower reads.
Score a candidate in one pass
This takes a handle and returns the numbers a decision actually needs: median engagement rate on mature posts, reply ratio, posting consistency and topical fit. It deliberately returns a row rather than a verdict, because the threshold belongs to your category rather than to a library.
import requests, statistics
from datetime import datetime, timedelta, timezone
BASE = "https://api.twitterapis.com/twitter"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}
MATURITY = timedelta(hours=48) # engagement is still accruing before this
def get(path, **params):
return requests.get(f"{BASE}/{path}", params=params,
headers=HEADERS, timeout=30).json()
def timeline(user_name, pages=2):
out, cursor = [], None
for _ in range(pages):
res = get("user/tweets", userName=user_name,
**({"cursor": cursor} if cursor else {}))
out += res.get("tweets") or []
if not res.get("has_more"):
break
cursor = res.get("next_cursor")
return out
def parse(ts):
return datetime.strptime(ts, "%a %b %d %H:%M:%S %z %Y")
def vet(user_name, topic_terms):
who = (get("user/info", userName=user_name).get("user") or {})
followers = max(who.get("followers_count") or 0, 1)
posts = timeline(user_name)
if not posts:
return {"handle": user_name, "verdict": "no recent posts"}
mature_before = datetime.now(timezone.utc) - MATURITY
rates, likes, replies, on_topic, dates = [], 0, 0, 0, []
for p in posts:
created = parse(p["createdAt"])
dates.append(created)
text = p["text"].lower()
if any(term in text for term in topic_terms):
on_topic += 1
if created > mature_before:
continue
like = p.get("likeCount") or 0
reply = p.get("replyCount") or 0
likes += like
replies += reply
rates.append(100 * (like + reply + (p.get("retweetCount") or 0)) / followers)
dates.sort()
gaps = [(b - a).days for a, b in zip(dates, dates[1:])] or [0]
return {
"handle": user_name,
"followers": followers,
# Median, not mean: one viral post should not carry a verdict.
"median_rate_pct": round(statistics.median(rates), 4) if rates else 0.0,
# Real communities argue. Likes without replies is the bought-audience tell.
"reply_ratio": round(replies / likes, 3) if likes else 0.0,
"max_gap_days": max(gaps),
"topic_fit_pct": round(100 * on_topic / len(posts)),
"scored_posts": len(rates),
}
for handle in ["creator_a", "creator_b"]:
print(vet(handle, ["postgres", "database", "sql"]))# Source: accounts whose display name or handle carries your niche words
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://api.twitterapis.com/twitter/user/search?query=devrel%20postgres"
# Source: who amplified a popular post in the niche
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://api.twitterapis.com/twitter/tweet/retweeters?id=1234567890"
# Vet: the profile behind a candidate
curl -H "Authorization: Bearer YOUR_API_KEY" \
"https://api.twitterapis.com/twitter/user/info?userName=creator_a"const BASE = "https://api.twitterapis.com/twitter";
const HEADERS = { Authorization: "Bearer YOUR_API_KEY" };
const MATURITY_MS = 48 * 60 * 60 * 1000;
const get = async (path, params) => {
const url = new URL(`${BASE}/${path}`);
for (const [k, v] of Object.entries(params)) url.searchParams.set(k, v);
return (await fetch(url, { headers: HEADERS })).json();
};
async function vet(userName, topicTerms) {
const who = (await get("user/info", { userName })).user ?? {};
const followers = Math.max(who.followers_count ?? 0, 1);
const posts = (await get("user/tweets", { userName })).tweets ?? [];
const matureBefore = Date.now() - MATURITY_MS;
const rates = [];
let likes = 0, replies = 0, onTopic = 0;
for (const p of posts) {
if (topicTerms.some((t) => p.text.toLowerCase().includes(t))) onTopic += 1;
if (Date.parse(p.createdAt) > matureBefore) continue;
const like = p.likeCount ?? 0, reply = p.replyCount ?? 0;
likes += like; replies += reply;
rates.push((100 * (like + reply + (p.retweetCount ?? 0))) / followers);
}
rates.sort((a, b) => a - b);
return {
handle: userName,
followers,
medianRatePct: +(rates[Math.floor(rates.length / 2)] ?? 0).toFixed(4),
replyRatio: likes ? +(replies / likes).toFixed(3) : 0,
topicFitPct: posts.length ? Math.round((100 * onTopic) / posts.length) : 0,
};
}
console.log(await vet("creator_a", ["postgres", "database"]));Two choices in there are deliberate. The score uses the median rather than the mean, because one post that travelled should not carry a verdict on a whole account. And the function returns a row instead of a pass or fail, because the right engagement threshold is a property of your category and your candidate set rather than something a script should assert.
Inspect the audience: catch a bought one for under a cent
A purchased following is visible in three places and none of them needs a specialist product. The first is engagement rate: a large account whose posts collect almost nothing has an audience that is not there. The second is the reply-to-like ratio, because bought engagement buys likes far more readily than it buys conversation, so an account with strong likes and near-zero replies is worth a second look.
The third is a direct sample. Page one follower list with GET /twitter/user/followers, which returns about 70 accounts, resolve ten of them through user/info, and read the creation dates and post counts. A cohort of accounts created in the same short window with nearly no posts is not subtle. Eleven calls, roughly $0.009, is the whole check.
None of these is proof on its own, and a real account can look bad on any single one. Treat them as a reason to look harder at a candidate rather than as a verdict a script should issue.
What a discovery run costs end to end
| Stage | Calls | Cost | Shape |
|---|---|---|---|
| Source 500 candidates from topic, name and handle searches | About 70 calls | About $0.06 | Sourcing is the cheap half by a wide margin |
| Vet 500 candidates on profile plus timeline | About 1,500 calls | About $1.20 | One profile call and two timeline pages each |
| Follower-quality sample on the top 50 | About 550 calls | About $0.44 | One follower page each, plus a ten-account profile sample |
| Monthly re-vet of a 200-creator roster | About 600 calls | About $0.48 a month | Catches a roster going stale before a campaign does |
The whole four-stage run above is roughly 2,720 calls, about $2.18. The re-vet row is the one most teams skip, and it is the one that catches a roster going stale before a campaign does rather than after.
Built for marketing agencies, brand teams, and creator platforms
Agencies run the sourcing-and-vetting pipeline above once per client brief and hand back a shortlist with the numbers attached, rather than a spreadsheet of follower counts nobody can defend to the client. Because every read is billed flat at $0.0008 with no seat fee, running the same pipeline across ten concurrent client briefs costs what it costs per candidate, not per seat added to the account.
In-house brand teams run it on a lighter cadence: one sourcing pass ahead of a campaign, then a re-vet pass close to launch to catch a roster that has gone stale since the shortlist was built. The four-stage run in the table above, source, vet, fraud-check, re-vet, is the same pipeline either way; the difference is how often a team re-runs it.
Creator platforms and marketplaces embed the same profile and timeline reads behind their own matching product, so a creator's engagement rate and posting consistency update on the platform's own schedule instead of at whatever cadence a manual spot-check happens to run.
By the numbers
Creator discovery on X, by the numbers
TwitterAPIs figures resolve to our published pricing. Every X figure is vendor-documented.
TwitterAPIs bills every profile, timeline, search and follower call at a flat $0.0008, with no plan tier and no per-seat fee. (TwitterAPIs pricing, 2026)
Sourcing and vetting 500 candidates is about 1,570 calls, which is roughly $1.26 at the published rate. (TwitterAPIs pricing, 2026)
Follower pages return about 70 records on the first page and fewer after, so a follower-quality sample is eleven calls, about $0.009. (TwitterAPIs pricing, 2026)
A new account starts with $0.50 in credit and no card, enough to source and vet several hundred candidates before you spend anything. (TwitterAPIs pricing, 2026)
The official X API meters user and post reads from about $0.005 per resource, one item per request, under its pay-per-use model. (X Developer Platform, 2026)
The official X API enforces per-endpoint rate limits in fixed 15-minute windows, which bounds how fast a candidate list can be vetted. (X API docs, 2026)
Influencer discovery, common questions
Filter on the numbers rather than on fame. Search for accounts posting about your topic, pull each profile, and keep the ones in your follower band, typically 1,000 to 50,000 for micro. Because profile reads are $0.0008 per call you can screen thousands of candidates for a few dollars, which is what makes the long tail workable at all; a per-seat tool that charges by the search tends to push you back toward the same well-known handles everyone else is pitching.
Sample rather than audit everything. Pull a few thousand followers, then compute what fraction have zero posts, a default avatar, or an account age clustered in a narrow window. Compare that against a creator you already trust in the same niche; the comparison is what makes the number mean something. Engagement is the second check: reach that does not move replies and reposts in proportion is the tell.
Automate the screening, keep the judgement manual. An API is very good at reducing ten thousand candidates to fifty on hard criteria: topic, follower band, posting cadence, engagement ratio, audience overlap with your existing customers. It is bad at deciding whether someone's voice suits your brand, and nobody should outsource that to a score. The useful split is machine for the funnel, human for the shortlist.
Source first, then vet. Sourcing means collecting candidates from category search results, name and handle search through GET /twitter/user/search, the accounts reposting popular posts in your niche through GET /twitter/tweet/retweeters, and a rival's follower list. Vetting means pulling each candidate's profile and recent timeline and computing engagement rate, reply ratio, posting consistency and topical fit. Sourcing 500 candidates costs around $0.06 and vetting them costs around $1.20 at a flat $0.0008 per call.
Judge it against the candidate set you are actually choosing between rather than an absolute benchmark, because rate falls predictably as follower count rises and category norms differ widely. As a working floor, below roughly 0.1 percent median engagement against followers, audience size has stopped meaning much. Rank your shortlist by rate rather than by reach, and expect the best rate in a set to belong to a smaller account.
Not directly. GET /twitter/user/search is X's People search, which matches display names and handles, not bio text. To use bios, source candidates first (topic authors, amplifiers, a rival's followers, or a name and handle search), then pull each profile with GET /twitter/user/info and filter on the bio yourself. Treat any bio match as a sourcing step rather than a result, since a bio is a self-description and says nothing about whether anyone engages with what that account posts.
No. TwitterAPIs authenticates with one Bearer token from signup, with no X developer application, no app review and no OAuth flow. Signup includes $0.50 in credit with no card on file, which is enough to source and vet several hundred candidates before you spend anything.
It gives you the raw signals to judge that yourself, which is the honest version of the answer. Pull a creator's followers and look at the distribution: account age, whether profiles have avatars and bios, follower-to-following ratios, and how many followers have never posted. A roster where most followers were created in the same window and never tweet is the classic bought-audience shape. We do not return a proprietary authenticity score, because that number would be our opinion rather than data.
For nearly every campaign, yes. Follower count is what an audience once was; engagement is what it currently does. A 10,000-follower account whose posts reliably draw hundreds of replies is usually worth more than a 500,000-follower account whose posts draw dozens. Both numbers come from the same endpoints here, so you can compute the ratio across a whole shortlist rather than trusting a media kit.
Yes, and it is the same endpoints pointed at a known list rather than at discovery. Poll each creator's timeline for posts matching your campaign hashtag or link, and pull engagement counts on a schedule to build the curve rather than a single end-of-campaign snapshot. At $0.0008 per call, tracking fifty creators hourly for a month is roughly $28.80.
Three signals, none of which needs a special product. Engagement rate is the first: an account with a large following and almost no engagement per post has an audience that is not present. Reply-to-like ratio is the second, because purchased engagement buys likes far more often than it buys conversation, so near-zero replies against high likes is a strong tell. The third is a follower sample: page one follower list, resolve a sample of those accounts, and look at creation dates and post counts. Ten profile calls, about $0.008, exposes an obviously bought audience.
Sourcing 500 candidates is about 70 calls, roughly $0.06. Vetting all 500 on profile plus two timeline pages each is about 1,500 calls, roughly $1.20. A follower-quality sample on the top 50 adds about 550 calls, near $0.44. Re-vetting a 200-creator roster monthly is about 600 calls, near $0.48. Compare that with per-seat influencer platforms, and the tradeoff is engineering time against a subscription.
Page GET /twitter/user/followers for both accounts and intersect on user id. High overlap means a campaign would mostly reach people who already follow you, which is a reason to negotiate differently rather than to walk away. This is the most expensive check on the page, because follower lists page at about 70 records on the first page and fewer after, so run it on a shortlist rather than on every candidate.
Usually because of the window and the maturity rule. Engagement accrues for days after a post, so a rate computed across posts of mixed ages understates the recent ones. Different tools also divide by different things, some by followers and some by estimated impressions, which produces numbers that are not comparable at all. Compute your own over a fixed window with a maturity cutoff, apply it identically to every candidate, and compare within your own set rather than against a figure from elsewhere.
Related use cases
The same follower and timeline reads power competitor analysis, and the same search pass that sources creators also surfaces buyers, which is lead generation. For the paging mechanics behind the audience checks, see the Twitter followers API. All fourteen workloads are indexed on the Twitter API use cases hub.
Build a vetted creator shortlist for pocket change
$0.0008 per call, $0.50 in free credit, no card and no X developer account.
Next read
Continue exploring related pages:
Twitter followers API
Export any account's followers and following with cursor pagination, $0.0008 a call, $0.04 per 1,000 tweets on full 20-tweet pages.
Twitter API use cases
14 use cases from sentiment analysis to lead generation.
Twitter API v2 pricing vs TwitterAPIs
Side-by-side endpoints, pricing, auth, and response shape, same data, 100x cheaper.