How to Find Crypto Influencers on X with TwexAPI
Crypto discovery on X is noisy. The same keyword can surface traders, founders, protocol accounts, NFT communities, meme accounts, scammy profiles, analysts, journalists, and bots. Manual search helps for a few handles, but it does not scale into a defensible shortlist.
TwexAPI's Search User endpoint gives you a structured starting point. Search keywords such as crypto analyst, DeFi founder, or Bitcoin trader, then compare the returned user profiles by bio fit, audience size, verification fields, and list membership before anyone reaches out.
What This Workflow Does
This workflow uses GET /twitter/search-user/{keyword}/{target_count} to find X accounts whose profile metadata matches crypto-related search phrases.
Use it for:
- Building a KOL shortlist for a crypto, DeFi, NFT, or Web3 campaign.
- Finding analysts, traders, and newsletter writers to monitor.
- Creating a seed list for community research or launch tracking.
- Comparing crypto accounts before moving them into a CRM or watchlist.
The endpoint returns candidate profiles. It does not validate investment claims, confirm audience authenticity, or replace compliance review. Treat the output as a research queue.
Endpoint
Send a GET request to:
https://api.twexapi.io/twitter/search-user/{keyword}/{target_count}| Path parameter | Type | Purpose |
|---|---|---|
keyword | string | Search phrase such as crypto analyst, DeFi founder, or Bitcoin trader. |
target_count | integer | Number of users to return. Start with 25 or 50 while tuning the search phrase. |
Authenticate with your TwexAPI bearer token.
curl --request GET \
--url 'https://api.twexapi.io/twitter/search-user/crypto%20analyst/50' \
--header 'Authorization: Bearer <token>'A successful response contains code, msg, and data. The data array contains user profile objects.
Useful fields include id, name, screen_name, description, description_urls, urls, location, followers_count, following_count, listed_count, statuses_count, is_blue_verified, is_verified, verified_type, can_dm, profile_image_url, profile_banner_url, created_at, and created_at_datetime.
1{
2 "code": 200,
3 "msg": "success",
4 "data": [
5 {
6 "id": "1717001045992251392",
7 "name": "Example Crypto Analyst",
8 "screen_name": "example_crypto",
9 "description": "Crypto markets, DeFi research, BTC and ETH commentary",
10 "followers_count": 88000,
11 "listed_count": 740,
12 "is_verified": true,
13 "is_blue_verified": true,
14 "verified_type": "blue",
15 "can_dm": true
16 }
17 ]
18}Pick Better Crypto Keywords
The keyword decides the quality of the candidate pool. Search intent matters more than volume.
| Goal | Example keywords |
|---|---|
| Market commentators | crypto analyst, Bitcoin trader, ETH analyst, onchain analyst |
| Protocol ecosystem | DeFi founder, Web3 founder, crypto protocol, L2 ecosystem |
| Community and content | crypto newsletter, crypto creator, NFT community, Web3 marketing |
| Investment and research | crypto VC, token analyst, DeFi research, macro crypto |
| Regional campaigns | Singapore crypto, Korea crypto, Japan Web3, Dubai crypto |
Run multiple narrow searches and keep the source keyword in your output. A candidate found through DeFi founder and a candidate found through meme coin usually need different review criteria.
Python Client
Use URL encoding for phrases with spaces. Keep request code separate from ranking logic so you can test each part independently.
1import os
2from typing import Any
3from urllib.parse import quote
4
5import requests
6
7TOKEN = os.environ["TWEXAPI_BEARER_TOKEN"]
8BASE_URL = "https://api.twexapi.io/twitter/search-user"
9
10def search_users(keyword: str, *, target_count: int = 50) -> list[dict[str, Any]]:
11 encoded_keyword = quote(keyword)
12 url = f"{BASE_URL}/{encoded_keyword}/{target_count}"
13
14 response = requests.get(
15 url,
16 headers={"Authorization": f"Bearer {TOKEN}"},
17 timeout=30,
18 )
19 response.raise_for_status()
20 return response.json().get("data", [])
21
22if __name__ == "__main__":
23 users = search_users("crypto analyst", target_count=25)
24 for user in users[:10]:
25 print(
26 user.get("screen_name"),
27 user.get("followers_count"),
28 user.get("description"),
29 )Normalize Profiles for a KOL Review Sheet
A crypto KOL workflow should make uncertainty visible. Save the keyword that found the account, the profile fields used for scoring, and the raw API response.
1from typing import Any
2
3CRYPTO_TERMS = [
4 "crypto",
5 "bitcoin",
6 "btc",
7 "ethereum",
8 "eth",
9 "defi",
10 "web3",
11 "nft",
12 "onchain",
13 "token",
14 "dao",
15 "solana",
16]
17
18RISK_TERMS = [
19 "signals",
20 "guaranteed",
21 "100x",
22 "pump",
23 "airdrop farming",
24]
25
26def contains_any(text: str, terms: list[str]) -> bool:
27 lowered = text.lower()
28 return any(term in lowered for term in terms)
29
30def to_kol_row(user: dict[str, Any], keyword: str) -> dict[str, Any]:
31 description = user.get("description") or ""
32 followers_count = user.get("followers_count") or 0
33 listed_count = user.get("listed_count") or 0
34
35 return {
36 "keyword": keyword,
37 "user_id": user.get("id"),
38 "screen_name": user.get("screen_name"),
39 "name": user.get("name"),
40 "description": description,
41 "location": user.get("location"),
42 "followers_count": followers_count,
43 "listed_count": listed_count,
44 "is_verified": user.get("is_verified") is True,
45 "is_blue_verified": user.get("is_blue_verified") is True,
46 "verified_type": user.get("verified_type"),
47 "can_dm": user.get("can_dm"),
48 "crypto_profile_match": contains_any(description, CRYPTO_TERMS),
49 "risk_term_match": contains_any(description, RISK_TERMS),
50 "profile_url": f"https://x.com/{user.get('screen_name')}",
51 "raw": user,
52 }Score Candidates Conservatively
Crypto campaigns need a stricter review queue than generic creator discovery. Penalize obvious risk terms and push uncertain profiles to manual review.
1import math
2
3def kol_score(row: dict[str, Any]) -> float:
4 score = 0.0
5
6 if row["crypto_profile_match"]:
7 score += 35
8 if row["is_verified"]:
9 score += 8
10 if row["is_blue_verified"]:
11 score += 4
12 if row["verified_type"] == "business":
13 score += 8
14 if row["risk_term_match"]:
15 score -= 20
16
17 followers = row["followers_count"] or 0
18 listed = row["listed_count"] or 0
19 score += min(math.log10(followers + 1) * 10, 45)
20 score += min(math.log10(listed + 1) * 7, 24)
21
22 return round(score, 2)
23
24keywords = [
25 "crypto analyst",
26 "DeFi founder",
27 "Bitcoin trader",
28 "onchain analyst",
29 "Web3 founder",
30]
31
32candidates = []
33seen_user_ids = set()
34
35for keyword in keywords:
36 for user in search_users(keyword, target_count=50):
37 user_id = user.get("id")
38 if not user_id or user_id in seen_user_ids:
39 continue
40 seen_user_ids.add(user_id)
41
42 row = to_kol_row(user, keyword)
43 row["score"] = kol_score(row)
44 row["review_status"] = "manual_review" if row["risk_term_match"] else "candidate"
45 candidates.append(row)
46
47candidates.sort(key=lambda row: row["score"], reverse=True)
48
49for row in candidates[:25]:
50 print(
51 row["score"],
52 row["review_status"],
53 row["screen_name"],
54 row["followers_count"],
55 row["profile_url"],
56 )This is intentionally conservative. The score should decide review order, not whether a creator is approved for paid promotion, token communication, or investor-facing messaging.
Save the Shortlist
Export a CSV for the review team and JSONL for raw storage. Keep risk_term_match visible so reviewers know why an account needs extra attention.
1import csv
2import json
3from datetime import datetime, timezone
4from pathlib import Path
5
6timestamp = datetime.now(timezone.utc).isoformat()
7csv_path = Path("crypto-kol-candidates.csv")
8jsonl_path = Path("crypto-kol-candidates.raw.jsonl")
9
10fieldnames = [
11 "score",
12 "review_status",
13 "keyword",
14 "screen_name",
15 "name",
16 "description",
17 "location",
18 "followers_count",
19 "listed_count",
20 "is_verified",
21 "is_blue_verified",
22 "verified_type",
23 "can_dm",
24 "crypto_profile_match",
25 "risk_term_match",
26 "profile_url",
27]
28
29with csv_path.open("w", newline="", encoding="utf-8") as f:
30 writer = csv.DictWriter(f, fieldnames=fieldnames)
31 writer.writeheader()
32 for row in candidates:
33 writer.writerow({field: row.get(field) for field in fieldnames})
34
35with jsonl_path.open("w", encoding="utf-8") as f:
36 for row in candidates:
37 f.write(json.dumps({
38 "fetched_at": timestamp,
39 "candidate": row,
40 }, ensure_ascii=False) + "\n")
41
42print(f"Saved {len(candidates)} crypto KOL candidates")Add Review Rules Before Outreach
A crypto influencer list should pass through policy and quality checks before anyone sends a message.
Use a review checklist like this:
- Confirm the profile is relevant to the campaign topic.
- Inspect recent posts for scams, undisclosed promotions, or audience mismatch.
- Check whether the account discusses tokens, protocols, or markets in a way your compliance rules allow.
- Confirm the contact path.
can_dmis a signal, not a delivery guarantee. - Record why the account was approved, rejected, or held for later review.
For crypto, the workflow is stronger when "no decision yet" is an explicit state. Do not force every discovered account into approve or reject.
Combine Search User with Other TwexAPI Endpoints
Search User gives you candidates. Use other endpoints to enrich the decision:
| Step | Endpoint type | Why it helps |
|---|---|---|
| Candidate discovery | Search User | Finds accounts by profile keyword. |
| Recent content review | User timeline or Advanced Search | Checks what the account actually posts. |
| Market conversation context | Cashtag Search | Finds posts around symbols such as $BTC, $ETH, or project tickers. |
| Audience mapping | Followers and following endpoints | Helps compare overlap with target communities. |
| Monitoring | Influencer monitoring workflow | Watches approved accounts after they enter a list. |
Keep these steps separate. Discovery, validation, and monitoring answer different questions.
Common Pitfalls
- Do not treat a crypto keyword match as endorsement or credibility.
- Do not use follower count as a proxy for audience quality.
- Do not automatically message every account with
can_dm: true. - Deduplicate by
id, not justscreen_name. - Save the keyword that discovered each account so reviewers can understand context.
- Store raw profiles and fetch timestamps because account metadata changes.
- Add extra review for accounts whose bios include promotional or high-risk language.
Wrap-up
TwexAPI's Search User endpoint helps turn crypto keywords into a structured KOL discovery workflow. Search specific phrases, normalize the returned profiles, score candidates conservatively, and keep risky or uncertain accounts in manual review.
That gives your team a cleaner way to build crypto influencer lists without treating noisy profile metadata as final truth.