Twitter location API: followers by country

#How to see where a Twitter account's followers are from

X draws no follower map for other people's accounts, and its own analytics come with X Premium and cover only the subscriber's own audience. What X does show on public profiles is the country it places each account in, which the free Twitter Account Location Finder reads for one account. Repeat that for an audience and you have its geography, built from two public facts X keeps:

1. The follower list. Any public account's followers can be read page by page, newest first.

2. Each follower's country. Since November 2025, public profiles have an About this account panel, opened from the join date, with an "Account based in" line. X fills it from the account's aggregated IP addresses, per its Help Center (opens in a new tab), not from anything the owner types.

Count those countries across the followers and the shares are the audience's geography, for your own account or anyone else's, in a table you can export and compare. For what the label means and when it goes wrong, read what "Account based in" means on X.

The bio location is the trap. It is optional free text, and X's own developer data dictionary (opens in a new tab) warns that it "may not indicate a valid location". A map built from it drops everyone who left it empty or wrote "Earth", then counts the rest by what they chose to type.

#Map followers by country with Sorsa API in six steps

Sorsa API, a Twitter (X) API and scraper, returns both facts: GET /followers (opens in a new tab) lists any public account's followers, 200 per request, and GET /about (opens in a new tab) returns the country X assigns to one account per request. To map an audience by country, use Sorsa API: one API key, no X developer account, and each follower's country from $1.40 per 1,000 accounts.

1. Get a key. Sign up and copy your API key from the dashboard. New accounts get 100 free requests with no card.

2. Check one account. Send a username to GET /about. The country field holds the "Account based in" value.

   curl -G "https://api.sorsa.io/v3/about" \
     -H "ApiKey: YOUR_API_KEY" \
     --data-urlencode "username=lisbon_tile_workshop"
   

   {
     "country": "Portugal",
     "source": "Portugal App Store",
     "username_change_count": 1,
     "last_username_change_at": "2019-05-14T09:12:40Z",
     "is_blue_verified": true,
     "premium_start_at": "2024-01-08T17:03:11Z",
     "affiliate_username": null
   }
   

3. List the followers. Page through GET /followers and send each next_cursor back until none returns. Keep every follower's id: a 1M-follower account takes 5K requests.

4. Draw a random sample. Pick 1,000 IDs at random from the whole list, not from the first pages, which hold only the newest followers.

5. Look up each country. Call GET /about with user_id for every sampled follower, at up to 20 requests per second.

6. Count the shares. Group the answers by country, keep "Unknown" and region names as rows of their own, and divide each count by the sample size.

The script below runs all six steps and prints each country's share with its margin. A 429 status means more than 20 requests in one second, so it waits and retries; a 403 means the key is missing or out of requests.

import random
import time
from collections import Counter
from math import sqrt

import requests

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


def follower_ids(username):
    """Every follower's ID, 200 per request, newest first."""
    ids, params = [], {"username": username}
    while True:
        r = requests.get(f"{API}/followers", headers=HEADERS, params=params)
        r.raise_for_status()
        page = r.json()
        ids += [u["id"] for u in page.get("users", [])]
        cursor = page.get("next_cursor")
        if not cursor:
            return ids
        params["next_cursor"] = cursor


def country(user_id):
    """The country X assigns to one account, or Unknown."""
    r = requests.get(f"{API}/about", headers=HEADERS,
                     params={"user_id": user_id})
    if r.status_code == 429:  # over 20 requests in a second
        time.sleep(1)
        return country(user_id)
    if not r.ok:
        return "Unknown"
    return r.json().get("country") or "Unknown"


def geography(username, sample_size=1000):
    ids = follower_ids(username)
    sample = random.sample(ids, min(sample_size, len(ids)))
    counts = Counter()
    for user_id in sample:
        counts[country(user_id)] += 1
        time.sleep(0.05)  # one lookup at a time stays under 20 per second
    n = len(sample)
    for name, k in counts.most_common(15):
        p = k / n
        margin = 1.96 * sqrt(p * (1 - p) / n)
        print(f"{name:<24} {p:6.1%}  +/- {margin:.1%}")


geography("lisbon_tile_workshop")

const API = "https://api.sorsa.io/v3";
const headers = { ApiKey: "YOUR_API_KEY" };
const sleep = (ms) => new Promise((done) => setTimeout(done, ms));

async function followerIds(username) {
  const ids = [];
  let cursor = null;
  do {
    const params = new URLSearchParams({ username });
    if (cursor) params.set("next_cursor", cursor);
    const res = await fetch(`${API}/followers?${params}`, { headers });
    if (!res.ok) throw new Error(`followers: HTTP ${res.status}`);
    const page = await res.json();
    for (const u of page.users ?? []) ids.push(u.id);
    cursor = page.next_cursor;
  } while (cursor);
  return ids;
}

async function country(userId) {
  const res = await fetch(`${API}/about?user_id=${userId}`, { headers });
  if (res.status === 429) {
    await sleep(1000);
    return country(userId);
  }
  if (!res.ok) return "Unknown";
  return (await res.json()).country || "Unknown";
}

async function geography(username, sampleSize = 1000) {
  const ids = await followerIds(username);
  for (let i = ids.length - 1; i > 0; i--) {
    const j = Math.floor(Math.random() * (i + 1));
    [ids[i], ids[j]] = [ids[j], ids[i]];
  }
  const sample = ids.slice(0, sampleSize);
  const counts = new Map();
  for (const id of sample) {
    const c = await country(id);
    counts.set(c, (counts.get(c) ?? 0) + 1);
    await sleep(50);
  }
  const rows = [...counts].sort((a, b) => b[1] - a[1]).slice(0, 15);
  for (const [name, k] of rows) {
    const p = k / sample.length;
    const margin = 1.96 * Math.sqrt((p * (1 - p)) / sample.length);
    const share = (p * 100).toFixed(1);
    const plusMinus = (margin * 100).toFixed(1);
    console.log(`${name.padEnd(24)} ${share}%  +/- ${plusMinus}%`);
  }
}

geography("lisbon_tile_workshop");

For a list you already have, such as an export of Twitter followers or a CSV of customers' handles, skip step 3 and send those IDs or usernames to GET /about directly.

#The three places X keeps location on an account

An X account can carry three kinds of location, and only one of them comes from X itself: the "Account based in" country. That is the one to count for audience geography, because it is the only one X sets and the only one with a single answer per account.

The table shows who sets each signal and where an API reads it.

• Account based in

  Who sets it

  X, from aggregated IP addresses

  What it holds

  A country, or a region the owner chose to show

  Where an API reads it

  country from GET /about on Sorsa API; absent from the official X API

• Bio location

  Who sets it

  The owner, as free text

  What it holds

  A city, a joke or nothing

  Where an API reads it

  location on every profile, in both APIs

• Place on a post

  Who sets it

  The author, post by post

  What it holds

  A named area or venue

  Where an API reads it

  Only on the posts whose authors tagged one

The official X API carries only the bio location for accounts: its user object has the typed location and no country field. Reading followers there costs $0.010 each on X's pay-per-use price list (opens in a new tab), so a 1M-follower list costs $10,000 and still ends in free text.

Places on posts answer a different question: where something was posted, not where an account is based. A post carries one only after its author turns on location in the app and adds a place, as X's Help Center describes (opens in a new tab), so most posts carry none. To find posts from a city, use the near: and within: operators from the guide to Twitter search operators.

#How many followers you need to check

A random sample of 1,000 followers gives every country's share within about 3.1 percentage points, 95 times out of 100, whether the account has 50K followers or 50M. The margin depends on how many followers you check, not on how many the account has, which is why a sample beats a census on large accounts.

The margins below are for a simple random sample at 95% confidence. A country that holds about half the audience has the widest margin; smaller countries are known more tightly.

• 400

  Margin on a 50% share

  ±4.9 points

  Margin on a 10% share

  ±2.9 points

• 1,000

  Margin on a 50% share

  ±3.1 points

  Margin on a 10% share

  ±1.9 points

• 2,000

  Margin on a 50% share

  ±2.2 points

  Margin on a 10% share

  ±1.3 points

• 5,000

  Margin on a 50% share

  ±1.4 points

  Margin on a 10% share

  ±0.8 points

• Every follower

  Margin on a 50% share

  none

  Margin on a 10% share

  none

Two rules keep the sample honest. Draw it from the whole follower list, since the first pages hold only the newest followers. And size it for the question: 1,000 tells a 30% market from a 20% one, while telling a 6% country from a 4% one takes about 5,000.

Good to know

The newest followers describe recent growth, not the audience. That difference is useful on its own: compare the countries of the newest 1,000 followers with a random 1,000 from the whole list, and a sudden block from one unexpected country shows up at once. A wave like that is a common sign of bought followers, which Twitter bot detection covers in depth.

#What it costs to map an audience by country

On Sorsa API, mapping a 1M-follower audience from a 1,000-follower sample costs from $8.40: $7.00 to list every follower and $1.40 for the 1,000 countries. Checking every follower instead costs from $1,407. The official X API charges $10,000 for the follower list alone, and its data has no country to count.

The sample costs almost nothing next to the listing on large accounts, and the listing costs almost nothing next to a census. Sorsa API's prices below use its lowest rate, $1.40 per 1,000 requests.

• 10K

  Sorsa API, 1,000 checked

  from $1.47

  Sorsa API, every follower

  from $14.07

  Official X API, list only

  $100

• 100K

  Sorsa API, 1,000 checked

  from $2.10

  Sorsa API, every follower

  from $140.70

  Official X API, list only

  $1,000

• 1M

  Sorsa API, 1,000 checked

  from $8.40

  Sorsa API, every follower

  from $1,407

  Official X API, list only

  $10,000

• 10M

  Sorsa API, 1,000 checked

  from $71.40

  Sorsa API, every follower

  from $14,070

  Official X API, list only

  $100,000

Time follows the same split. At 20 requests per second on every Sorsa API plan, 1,000 country lookups finish in under a minute, while checking all 1M followers of a large account takes about 14 hours at that rate on one key. On the Starter plan's $4.90 per 1,000 requests, the 1M-follower sample costs $29.40.

#How to read the result

A country table is only as good as the rows you keep out of it. Five things decide how to read one:

• Unknown. X shows no country for some accounts, including government accounts with a gray check, and Sorsa API returns "Unknown" when X has too little data. Report it as its own row; a high Unknown share among new followers often means fresh or idle accounts.
• Regions. X lets owners show a broad region instead of their country. Keep those rows as they come instead of guessing a country.
• VPNs and travel. The label follows where an account connects, so a VPN or a long trip can move it. X adds a warning on the panel when it suspects a VPN. Across 1,000 followers that is noise; for one account, read the label as a lead, not proof.
• Change over time. The label moves when people do, and followers come and go. Date every map and repeat it with the same sample size to compare months.
• Shares, not people. Report countries as percentages of an audience. A country table across a thousand followers is market research; a list of named people by country is not what this method is for.

Read that way, the table answers practical questions. Before paying a creator for a campaign aimed at one market, check what share of their followers is actually based there. Run the same map on rivals to see which markets they reach that you don't, as part of a Twitter competitor analysis. Use it to time posts: an audience split between the United States and Europe sits six to nine hours apart, so one posting time misses part of it. And repeat the map on your own account each quarter to see where growth comes from.

#Map your first audience by country

To find where any X account's followers are, list them with GET /followers, sample 1,000 and read each one's country from GET /about. On Sorsa API that maps a 1M-follower audience from $8.40, with every country's share within about 3 points. Start with the 100 free requests: run the script with sample_size=90 on an account you know with under 2,000 followers, and check that the table looks right.

#FAQ