Twitter User ID to Creation Date - Find Account Join Date (Free Tool)

Last updated March 22, 2026

How to Find Twitter User ID

To use this converter, you need the Twitter user ID (not the @username). Here's how to find it:

• Use Twitter's API or third-party tools to get the numeric user ID
• Check the user's profile URL in some Twitter clients
• Use browser developer tools to inspect profile data
• Use online Twitter ID lookup tools

Twitter User ID to Creation Date Converter — Examples

Twitter user IDs are Snowflake IDs that encode the account creation date in their first 41 bits. Here are examples showing how to extract the creation date from any Twitter user ID.

Basic Conversion

// JavaScript — get account creation date from user ID
function getUserCreationDate(userIdStr) {
  const id = BigInt(userIdStr);
  const TWITTER_EPOCH = 1288834974657n;
  
  // Pre-Snowflake check (accounts created before Nov 2010)
  if (id < 27_000_000_000n) {
    return { error: "Pre-Snowflake account — exact creation date not encoded in ID" };
  }
  
  const timestampMs = (id >> 22n) + TWITTER_EPOCH;
  const date = new Date(Number(timestampMs));
  
  return {
    userId: userIdStr,
    createdAt: date.toISOString(),
    createdDate: date.toDateString(),
    createdTime: date.toTimeString().split(" ")[0] + " UTC"
  };
}

// Example
console.log(getUserCreationDate("1234567890123456789"));

# Python — get account creation date from user ID
from datetime import datetime, timezone

TWITTER_EPOCH_MS = 1288834974657

def get_user_creation_date(user_id_str):
    id_val = int(user_id_str)
    
    if id_val < 27_000_000_000:
        return {"error": "Pre-Snowflake account — creation date not encoded in ID"}
    
    ts_ms = (id_val >> 22) + TWITTER_EPOCH_MS
    dt = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
    
    return {
        "user_id": user_id_str,
        "created_at": dt.isoformat(),
        "created_date": dt.strftime("%B %d, %Y"),
        "created_time": dt.strftime("%H:%M:%S UTC")
    }

print(get_user_creation_date("1234567890123456789"))

Batch Account Age Analysis

# Python — analyze creation dates for a list of user IDs
from datetime import datetime, timezone

TWITTER_EPOCH_MS = 1288834974657

def analyze_account_ages(user_ids):
    """
    Analyze the creation dates of a list of Twitter user IDs.
    Useful for detecting bulk-created accounts (potential bots).
    """
    results = []
    
    for id_str in user_ids:
        id_val = int(id_str)
        if id_val < 27_000_000_000:
            results.append({"id": id_str, "era": "pre-snowflake"})
            continue
        
        ts_ms = (id_val >> 22) + TWITTER_EPOCH_MS
        dt = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
        results.append({
            "id": id_str,
            "created_at": dt.isoformat(),
            "year": dt.year,
            "month": dt.month
        })
    
    return results

# Example: check if accounts were created in bulk
user_ids = [
    "1234567890123456789",
    "1234567890123456800",
    "1234567890123456900",
]

results = analyze_account_ages(user_ids)
for r in results:
    print(r)

Detecting Coordinated Account Creation

// JavaScript — detect accounts created within a short time window
// (potential indicator of coordinated inauthentic behavior)

function detectBulkCreation(userIds, windowMs = 60000) {
  const TWITTER_EPOCH = 1288834974657n;
  
  const decoded = userIds
    .filter(id => BigInt(id) >= 27_000_000_000n)
    .map(id => ({
      id,
      tsMs: Number((BigInt(id) >> 22n) + TWITTER_EPOCH)
    }))
    .sort((a, b) => a.tsMs - b.tsMs);
  
  const clusters = [];
  let currentCluster = [decoded[0]];
  
  for (let i = 1; i < decoded.length; i++) {
    const timeDiff = decoded[i].tsMs - currentCluster[0].tsMs;
    if (timeDiff <= windowMs) {
      currentCluster.push(decoded[i]);
    } else {
      if (currentCluster.length > 1) clusters.push(currentCluster);
      currentCluster = [decoded[i]];
    }
  }
  if (currentCluster.length > 1) clusters.push(currentCluster);
  
  return clusters.map(cluster => ({
    count: cluster.length,
    windowMs: cluster[cluster.length - 1].tsMs - cluster[0].tsMs,
    ids: cluster.map(c => c.id)
  }));
}

const ids = ["1234567890123456789", "1234567890123456800", "9999999999999999999"];
console.log(detectBulkCreation(ids));

Account Age Calculation

// Calculate how old a Twitter account is from its user ID
function getAccountAge(userIdStr) {
  const id = BigInt(userIdStr);
  const TWITTER_EPOCH = 1288834974657n;
  
  if (id < 27_000_000_000n) {
    return "Account predates Snowflake IDs (created before Nov 2010)";
  }
  
  const tsMs = Number((id >> 22n) + TWITTER_EPOCH);
  const ageMs = Date.now() - tsMs;
  
  const days  = Math.floor(ageMs / 86400000);
  const years = Math.floor(days / 365);
  const months = Math.floor((days % 365) / 30);
  
  if (years > 0) return `${years} year${years > 1 ? "s" : ""}, ${months} month${months !== 1 ? "s" : ""}`;
  if (days > 30) return `${months} month${months !== 1 ? "s" : ""}`;
  return `${days} day${days !== 1 ? "s" : ""}`;
}

console.log(getAccountAge("1234567890123456789"));

No API Required

The creation date is encoded directly in the user ID — no Twitter API call is needed:

# Python — decode creation date without any API call
from datetime import datetime, timezone

def decode_without_api(user_id_str):
    """
    Extract account creation date from user ID alone.
    No API key, no rate limits, no network request needed.
    """
    id_val = int(user_id_str)
    
    if id_val < 27_000_000_000:
        return "Pre-Snowflake account — use Twitter API for creation date"
    
    ts_ms = (id_val >> 22) + 1288834974657
    dt = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
    
    return {
        "user_id": user_id_str,
        "created_at": dt.isoformat(),
        "method": "Decoded from Snowflake ID — no API call needed"
    }

print(decode_without_api("1234567890123456789"))

Pre-Snowflake Accounts

• Accounts created before November 2010 have small user IDs (under ~27 billion)
• These IDs are sequential integers without embedded timestamps
• For pre-Snowflake accounts, use the Twitter API to get the creation date
• The created_at field in the API response gives the creation date for all accounts

The user ID to creation date conversion is a powerful tool for researchers and journalists. The creation date is permanently encoded in the ID and cannot be changed after account creation, making it a reliable and objective source of information about when an account was established.