Twitter User API: Look Up Any Profile at $0.0008/call

What this API does

A Twitter user lookup resolves a handle like @elonmusk or a numeric id like 44196397 into a full profile object containing bio, follower count, following count, verification status, location, account creation date, and pinned tweet ids. TwitterAPIs exposes this across four endpoints at a flat $0.0008 per call, part of a 121-endpoint surface that also covers tweets, followers, and search, all on the same key.

Fetch a profile by handle

The main user lookup lives at GET /twitter/user/info. Pass the userName without the @ symbol and you get the full profile object in one call at $0.0008.

Look up a user by handle

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/info?userName=elonmusk"

import requests

def get_user_by_handle(user_name: str) -> dict:
    resp = requests.get(
        "https://api.twitterapis.com/twitter/user/info",
        params={"userName": user_name},
        headers={"Authorization": "Bearer YOUR_API_KEY"},
    )
    resp.raise_for_status()
    return resp.json()["user"]

user = get_user_by_handle("elonmusk")
print(user["followers_count"])   # e.g. 180000000
print(user["is_blue_verified"])  # True / False
print(user["description"])       # bio text

async function getUserByHandle(userName) {
  const url = new URL("https://api.twitterapis.com/twitter/user/info");
  url.searchParams.set("userName", userName);
  const res = await fetch(url, {
    headers: { Authorization: "Bearer YOUR_API_KEY" },
  });
  return (await res.json()).user;
}

const user = await getUserByHandle("elonmusk");
console.log(user.followers_count);   // e.g. 180000000
console.log(user.is_blue_verified);  // true / false
console.log(user.description);       // bio text

Look up a user by numeric id

curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/info_by_id?userId=44196397"

import requests

def get_user_by_id(user_id: str) -> dict:
    resp = requests.get(
        "https://api.twitterapis.com/twitter/user/info_by_id",
        params={"userId": user_id},
        headers={"Authorization": "Bearer YOUR_API_KEY"},
    )
    resp.raise_for_status()
    return resp.json()["user"]

# Numeric ids survive handle renames -- safer for long-term storage
user = get_user_by_id("44196397")
print(user["username"])   # current handle, whatever it is today
print(user["created_at"])    # account creation date

async function getUserById(userId) {
  const url = new URL("https://api.twitterapis.com/twitter/user/info_by_id");
  url.searchParams.set("userId", userId);
  const res = await fetch(url, {
    headers: { Authorization: "Bearer YOUR_API_KEY" },
  });
  return (await res.json()).user;
}

// Numeric ids survive handle renames
const user = await getUserById("44196397");
console.log(user.username);  // current handle
console.log(user.created_at);   // account creation date

Both endpoints return the same profile payload. Store numeric ids in your database to avoid broken references if a user renames their account. Read the info_by_id docs.

Extended profile: user_about and affiliates

user/user_about returns the expanded profile card including the full pinned Tweet object. user/affiliates returns any X-linked accounts affiliated with the target user, such as organizational labels and related brands.

# Extended about section with full pinned tweet object
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/user_about?userName=elonmusk"

# List affiliated accounts (orgs, brands, labels linked by X)
curl -H "Authorization: Bearer YOUR_API_KEY" \
  "https://api.twitterapis.com/twitter/user/affiliates?userName=SpaceX"

import requests

BASE = "https://api.twitterapis.com/twitter/user"
HEADERS = {"Authorization": "Bearer YOUR_API_KEY"}

def get_about(user_name: str) -> dict:
    """Full pinned tweet object + expanded profile."""
    return requests.get(f"{BASE}/user_about", params={"userName": user_name},
                        headers=HEADERS).json()

def get_affiliates(user_name: str) -> list:
    """Accounts X has linked as affiliates of this user."""
    data = requests.get(f"{BASE}/affiliates", params={"userName": user_name},
                        headers=HEADERS).json()
    return data.get("users", [])

about = get_about("elonmusk")
print(about.get("pinned_tweet", {}).get("full_text", ""))

for aff in get_affiliates("X"):
    print(aff["username"], aff["followers_count"])

Pricing: flat $0.0008 per lookup

There is no subscription and no minimum. 1,000 lookups costs $0.80. 10,000 lookups costs $8. See the complete rate card on the Twitter API pricing page or get your key on the pricing page.

Official X API vs a public-data API for profile reads

There are two ways to read a public X profile from code. The official X API bills every read from the first request: X moved self-serve access to consumption billing in February 2026, and a user read is $0.010, with no free tier and no subscription to hold the price down. A public-data API such as TwitterAPIs reads the same public profile for $0.0008 per call, on a key you get at signup, with no X developer account and no OAuth app. The rates are the ones our Twitter API pricing page tracks.

What reading public X data costs at volume

For profiles the arithmetic is simple, because one call returns one profile. A thousand profile reads cost $10 on the official API and $0.80 here. A hundred thousand, the size of a typical lead list or follower audit, cost $1,000 and $80. The official API earns its price when you need what only it offers, such as writing as your own authenticated app or data X does not show publicly. For reading public profiles, you are paying for access you do not use.

A real public-data request, end to end

One GET with a Bearer header is the whole integration: call GET /twitter/user/info with userName set to the handle, without the @. The response is one JSON object with a single user key holding the fields in the table above: the stable numeric id, display name, bio, follower and following counts, tweet count, both verification flags, location, creation date, pinned tweet ids and image URLs. It costs one call, $0.0008. If you store the numeric id and read by id afterwards, a user renaming their handle never breaks your record.

Common use cases for the User API

Lead enrichment

Turn a list of handles into bios, locations, website links and follower counts, then score or route each lead. At one call per profile, enriching 10,000 leads is $8.

Bot and fake-follower screening

Account age, follower-to-following ratio, tweet count and verification together flag most automated accounts before you pay them attention. The method is set out in how to detect bot accounts programmatically.

Influencer and creator vetting

Check that an account's audience matches the claim before a paid collaboration: follower count, growth since the account was created, and whether the affiliated accounts endpoint shows the brand links the creator describes.

Tracking accounts over time

Read the same profiles on a schedule and store each snapshot against the numeric id. The difference between snapshots is follower growth, bio changes and renamed handles, which is the raw material for competitor monitoring and research datasets.

User profiles are one surface of 121 endpoints

The same Bearer key that resolves profiles also covers follower lists, tweet timelines, and keyword search. Use the Twitter Followers API to page through a full follower or following list once you have the user id. For keyword and hashtag data, the Twitter Search API runs on the same key. To wire profile lookups into an AI agent, use the MCP server at @twitterapis/mcp. For your API key and account setup, visit the Twitter API key page. Full endpoint reference lives in the docs.