Twitter Snowflake ID Decoder Online - Free Tool

// JavaScript
const TWITTER_EPOCH = 1288834974657n;
function decodeTwitterId(id) {
  const snowflake = BigInt(id);
  const timestamp = Number((snowflake >> 22n) + TWITTER_EPOCH);
  const workerId = Number((snowflake >> 17n) & 0x1Fn);
  const sequence = Number(snowflake & 0xFFFn);
  return { timestamp, workerId, sequence, date: new Date(timestamp) };
}

Twitter Snowflake ID Decoder — Examples

The Twitter Snowflake ID Decoder extracts the creation timestamp, datacenter ID, worker ID, and sequence number from any Twitter Snowflake ID. Here are complete examples showing the decoding process and all output formats.

Core Decoding Algorithm

// JavaScript — complete Snowflake decoder
const TWITTER_EPOCH = 1288834974657n; // Nov 4, 2010 01:42:54 UTC

function decodeSnowflake(idStr) {
  const id = BigInt(idStr);
  
  // Extract components via bit manipulation
  const timestampMs  = (id >> 22n) + TWITTER_EPOCH;
  const datacenterId = Number((id >> 17n) & 0x1Fn);
  const workerId     = Number((id >> 12n) & 0x1Fn);
  const sequence     = Number(id & 0xFFFn);
  const date         = new Date(Number(timestampMs));
  
  return {
    id: idStr,
    utc:          date.toUTCString(),
    iso8601:      date.toISOString(),
    unixMs:       timestampMs.toString(),
    unixSeconds:  Math.floor(Number(timestampMs) / 1000),
    datacenterId,
    workerId,
    sequence
  };
}

console.log(decodeSnowflake("1529877576591609861"));

Python Implementation

# Python — Snowflake decoder
from datetime import datetime, timezone

TWITTER_EPOCH_MS = 1288834974657

def decode_snowflake(id_str):
    id_val = int(id_str)
    
    timestamp_ms  = (id_val >> 22) + TWITTER_EPOCH_MS
    datacenter_id = (id_val >> 17) & 0x1F
    worker_id     = (id_val >> 12) & 0x1F
    sequence      = id_val & 0xFFF
    
    dt = datetime.fromtimestamp(timestamp_ms / 1000, tz=timezone.utc)
    
    return {
        "id": id_str,
        "utc": dt.strftime("%Y-%m-%d %H:%M:%S UTC"),
        "iso8601": dt.isoformat(),
        "unix_ms": timestamp_ms,
        "unix_s": timestamp_ms // 1000,
        "datacenter_id": datacenter_id,
        "worker_id": worker_id,
        "sequence": sequence
    }

result = decode_snowflake("1529877576591609861")
for k, v in result.items():
    print(f"{k}: {v}")

Binary Representation

// Show the binary breakdown of a Snowflake ID
function showBinary(idStr) {
  const id = BigInt(idStr);
  const bin = id.toString(2).padStart(64, "0");
  
  console.log("ID:", idStr);
  console.log("Binary (64 bits):", bin);
  console.log("");
  console.log("Timestamp  [63-22] 41 bits:", bin.slice(0, 41));
  console.log("Datacenter [21-17]  5 bits:", bin.slice(41, 46));
  console.log("Worker     [16-12]  5 bits:", bin.slice(46, 51));
  console.log("Sequence   [11-0]  12 bits:", bin.slice(51, 64));
}

showBinary("1529877576591609861");

Decoding User IDs

# Twitter user IDs use the same Snowflake format
# Decode to find when an account was created

def get_account_creation_date(user_id_str):
    """
    Decode a Twitter user ID to find the account creation date.
    Works for Snowflake-era accounts (created after Nov 2010).
    """
    id_val = int(user_id_str)
    
    # Pre-Snowflake check
    if id_val < 27_000_000_000:
        return "Pre-Snowflake account — creation date not encoded in ID"
    
    ts_ms = (id_val >> 22) + 1288834974657
    from datetime import datetime, timezone
    dt = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
    return dt.strftime("%Y-%m-%d %H:%M:%S UTC")

# Example
print(get_account_creation_date("1234567890123456789"))

Verifying Tweet Authenticity

// Verify a tweet's timestamp from its ID
// The decoded timestamp cannot be manipulated (unlike a screenshot)

function verifyTweetDate(tweetUrl) {
  const match = tweetUrl.match(/\/status\/(\d+)/);
  if (!match) return { error: "No tweet ID found in URL" };
  
  const decoded = decodeSnowflake(match[1]);
  
  return {
    tweetId: match[1],
    createdAt: decoded.iso8601,
    note: "This timestamp is derived from the tweet ID and cannot be falsified"
  };
}

const url = "https://twitter.com/user/status/1529877576591609861";
console.log(verifyTweetDate(url));

Batch Decoding

# Python — batch decode and export to CSV
import csv
from datetime import datetime, timezone

def batch_decode(id_list):
    results = []
    for id_str in id_list:
        id_val = int(id_str)
        ts_ms = (id_val >> 22) + 1288834974657
        dt = datetime.fromtimestamp(ts_ms / 1000, tz=timezone.utc)
        results.append({
            "id": id_str,
            "created_at": dt.isoformat(),
            "datacenter": (id_val >> 17) & 0x1F,
            "worker": (id_val >> 12) & 0x1F,
            "sequence": id_val & 0xFFF
        })
    return results

ids = ["1529877576591609861", "1700000000000000000", "1800000000000000000"]
results = batch_decode(ids)

with open("decoded.csv", "w", newline="") as f:
    writer = csv.DictWriter(f, fieldnames=results[0].keys())
    writer.writeheader()
    writer.writerows(results)

print(f"Exported {len(results)} rows to decoded.csv")

Reverse: Date to Snowflake ID

// Convert a date to the minimum Snowflake ID for that moment
// Use as since_id in Twitter API queries

function dateToSnowflakeId(date) {
  const TWITTER_EPOCH = 1288834974657n;
  const tsMs = BigInt(date.getTime()) - TWITTER_EPOCH;
  return (tsMs << 22n).toString();
}

// Get ID range for a time period
function getIdRange(startDate, endDate) {
  return {
    since_id: dateToSnowflakeId(startDate),
    max_id: dateToSnowflakeId(endDate)
  };
}

const range = getIdRange(
  new Date("2023-01-01T00:00:00Z"),
  new Date("2023-12-31T23:59:59Z")
);
console.log("2023 ID range:", range);

Snowflake Component Reference

• Bits 63–22 (41 bits): Timestamp — milliseconds since Nov 4, 2010
• Bits 21–17 (5 bits): Datacenter ID — 0 to 31
• Bits 16–12 (5 bits): Worker ID — 0 to 31
• Bits 11–0 (12 bits): Sequence — 0 to 4095 per millisecond per worker

The decoder works identically for tweet IDs, user IDs, direct message IDs, and all other Twitter Snowflake IDs. The same algorithm, the same epoch, the same bit layout — every Twitter entity uses the same Snowflake format.

Common Use Cases

• Find when tweets were posted from tweet IDs
• Determine Twitter account creation dates from user IDs
• Analyze Twitter activity timelines
• Debug Twitter bot timing issues
• Verify tweet timestamps for research or forensics