GET https://api.twitterxapi.com/twitter/latest-followers/{screen_name}

Authorization: Bearer <your_token>

1{
2  "code": 200,
3  "msg": "success",
4  "data": [
5    {
6      "userId": "12345678",
7      "name": "User Name",
8      "username": "username",
9      "description": "User bio",
10      "location": "Geographic location",
11      "followersCount": 1000,
12      "fastFollowersCount": 950,
13      "normalFollowersCount": 50,
14      "favouritesCount": 2500,
15      "statusesCount": 850,
16      "listedCount": 25,
17      "mediaCount": 120,
18      "verified": true,
19      "isBlueVerified": false,
20      "protected": false,
21      "profileImageUrlHttps": "https://...",
22      "createdAt": "2020-01-01",
23      "createdAtDatetime": "2020-01-01T00:00:00.000Z",
24      "pinnedTweetIds": [],
25      "url": "https://example.com"
26    }
27  ]
28}

// Analyze competitor follower composition
const competitors = ['competitor1', 'competitor2', 'competitor3'];
const analysis = await Promise.all(
  competitors.map(user => analyzer.generateReport(user))
);

# Find high-influence followers for collaboration
def find_potential_partners(followers_data):
    influencers = [
        f for f in followers_data 
        if f['followersCount'] > 50000 and f['verified']
    ]
    return sorted(influencers, key=lambda x: x['followersCount'], reverse=True)

1// Analyze follower geographic distribution and characteristics
2function analyzeAudience(followers) {
3  const locations = followers.map(f => f.location).filter(Boolean);
4  const locationCounts = locations.reduce((acc, loc) => {
5    acc[loc] = (acc[loc] || 0) + 1;
6    return acc;
7  }, {});
8  
9  return Object.entries(locationCounts)
10    .sort(([,a], [,b]) => b - a)
11    .slice(0, 10);
12}

1// Implement request rate limiting
2class RateLimiter {
3  constructor(requestsPerMinute = 60) {
4    this.requests = [];
5    this.limit = requestsPerMinute;
6  }
7  
8  async throttle() {
9    const now = Date.now();
10    this.requests = this.requests.filter(time => now - time < 60000);
11    
12    if (this.requests.length >= this.limit) {
13      const waitTime = 60000 - (now - this.requests[0]);
14      await new Promise(resolve => setTimeout(resolve, waitTime));
15    }
16    
17    this.requests.push(now);
18  }
19}

1import json
2import os
3from datetime import datetime, timedelta
4
5class FollowersCache:
6    def __init__(self, cache_dir='cache'):
7        self.cache_dir = cache_dir
8        os.makedirs(cache_dir, exist_ok=True)
9    
10    def get_cache_file(self, screen_name):
11        return os.path.join(self.cache_dir, f"{screen_name}_followers.json")
12    
13    def is_cache_valid(self, screen_name, hours=24):
14        cache_file = self.get_cache_file(screen_name)
15        if not os.path.exists(cache_file):
16            return False
17            
18        mod_time = datetime.fromtimestamp(os.path.getmtime(cache_file))
19        return datetime.now() - mod_time < timedelta(hours=hours)
20    
21    def get_cached_data(self, screen_name):
22        if self.is_cache_valid(screen_name):
23            with open(self.get_cache_file(screen_name), 'r') as f:
24                return json.load(f)
25        return None
26    
27    def save_to_cache(self, screen_name, data):
28        with open(self.get_cache_file(screen_name), 'w') as f:
29            json.dump(data, f, indent=2)

1async function robustFollowersRetrieval(screenName, maxRetries = 3) {
2  for (let attempt = 1; attempt <= maxRetries; attempt++) {
3    try {
4      const data = await getLatestFollowers(screenName);
5      return data;
6    } catch (error) {
7      console.log(`❌ Attempt ${attempt}/${maxRetries} failed:`, error.message);
8      
9      if (attempt === maxRetries) {
10        throw new Error(`Failed to fetch followers for ${screenName} after ${maxRetries} retries`);
11      }
12      
13      const delay = Math.pow(2, attempt) * 1000;
14      await new Promise(resolve => setTimeout(resolve, delay));
15    }
16  }
17}