Twitter Snowflake Decoder Online - Free ID to Date Converter

1382350606417817604 → April 14, 2021, 15:30:06 UTC

1800000000000000000 → July 10, 2024, 12:00:00 UTC

2024288437327843509 → December 15, 2024, 08:45:30 UTC

Twitter Snowflake Decoder Online — Examples

The Twitter Snowflake Decoder Online decodes any Twitter ID directly in your browser — no installation required. All decoding happens locally using JavaScript, so your IDs are never sent to any server. Here are examples of how to use it and how the decoding works.

Decoding a Tweet ID

Paste any tweet ID or Twitter URL into the decoder. For example, from the URL:

https://twitter.com/user/status/1529877576591609861

The decoder extracts the ID 1529877576591609861 and produces:

• UTC datetime: May 26, 2022 (approximate)
• ISO 8601: 2022-05-26T...
• Unix timestamp (ms): ~1653572200000
• Datacenter ID: extracted from bits 21–17
• Worker ID: extracted from bits 16–12
• Sequence: extracted from bits 11–0

How the Browser-Side Decoding Works

// The decoder runs this logic entirely in your browser
function decodeSnowflake(idStr) {
  const id = BigInt(idStr);
  const twitterEpoch = 1288834974657n; // Nov 4, 2010 UTC
  
  const timestampMs = (id >> 22n) + twitterEpoch;
  const datacenterId = Number((id >> 17n) & 0x1Fn);
  const workerId = Number((id >> 12n) & 0x1Fn);
  const sequence = Number(id & 0xFFFn);
  const date = new Date(Number(timestampMs));
  
  return {
    utc: date.toUTCString(),
    iso8601: date.toISOString(),
    unixMs: timestampMs.toString(),
    unixSeconds: Math.floor(Number(timestampMs) / 1000),
    datacenterId,
    workerId,
    sequence
  };
}

// No data leaves your browser — all computation is local
console.log(decodeSnowflake("1529877576591609861"));

Parsing IDs from Twitter URLs

// Extract tweet ID from a Twitter/X URL
function extractIdFromUrl(url) {
  const patterns = [
    /twitter\.com\/\w+\/status\/(\d+)/,
    /x\.com\/\w+\/status\/(\d+)/,
    /^(\d{10,20})$/  // plain numeric ID
  ];
  
  for (const pattern of patterns) {
    const match = url.match(pattern);
    if (match) return match[1];
  }
  return null;
}

// Examples
const urls = [
  "https://twitter.com/user/status/1529877576591609861",
  "https://x.com/user/status/1700000000000000000",
  "1800000000000000000"
];

urls.forEach(url => {
  const id = extractIdFromUrl(url);
  if (id) {
    const decoded = decodeSnowflake(id);
    console.log(`ID: ${id} → ${decoded.iso8601}`);
  }
});

Batch Decoding Multiple IDs

// Decode a list of IDs at once
function batchDecode(idList) {
  return idList
    .map(id => id.trim())
    .filter(id => /^\d+$/.test(id))
    .map(id => ({
      id,
      ...decodeSnowflake(id)
    }));
}

const ids = [
  "1529877576591609861",
  "1700000000000000000",
  "1800000000000000000",
  "1900000000000000000"
];

const results = batchDecode(ids);
results.forEach(r => {
  console.log(`${r.id} → ${r.iso8601}`);
});

Reverse Decode: Date to Snowflake ID

// Find the minimum Snowflake ID for a given date
// Useful for Twitter API since_id parameter
function dateToSnowflakeId(date) {
  const twitterEpoch = 1288834974657n;
  const tsMs = BigInt(date.getTime()) - twitterEpoch;
  
  if (tsMs < 0n) {
    throw new Error("Date is before Twitter's Snowflake epoch (Nov 4, 2010)");
  }
  
  return (tsMs << 22n).toString();
}

// Example: get the min ID for a specific date
const date = new Date("2023-06-01T00:00:00Z");
const minId = dateToSnowflakeId(date);
console.log("Min ID for 2023-06-01:", minId);

// Use in API query
const apiUrl = `https://api.twitter.com/2/tweets/search/recent?since_id=${minId}`;

Binary Representation

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

showBinaryBreakdown("1529877576591609861");

Privacy Note

The online decoder processes all IDs locally in your browser using JavaScript's BigInt API. No ID data is transmitted to any server. This makes it safe to use with:

• Private or sensitive tweet IDs
• User IDs from internal datasets
• IDs from non-public Twitter accounts
• Large batches of IDs from research datasets

Handling Edge Cases

// Handle pre-Snowflake IDs and invalid inputs
function safeDecodeSnowflake(idStr) {
  try {
    const id = BigInt(idStr);
    
    if (id <= 0n) {
      return { error: "ID must be a positive integer" };
    }
    
    // Pre-Snowflake IDs are typically under ~27 billion
    if (id < 27000000000n) {
      return { error: "This appears to be a pre-Snowflake ID (before Nov 2010) — timestamp not encoded" };
    }
    
    return decodeSnowflake(idStr);
  } catch (e) {
    return { error: "Invalid ID format — must be a numeric string" };
  }
}

console.log(safeDecodeSnowflake("783214"));              // pre-Snowflake
console.log(safeDecodeSnowflake("1529877576591609861")); // valid
console.log(safeDecodeSnowflake("not-a-number"));        // invalid

The online decoder is the fastest way to decode a Twitter Snowflake ID without writing any code. Paste an ID or URL, get the timestamp instantly, all in your browser.

How to Use This Online Tool

1. Copy any Twitter user ID or tweet ID

2. Paste it into the decoder above

3. Click "Decode Online" to see the creation date

4. Results appear instantly - no waiting, no downloads