Snowflake ID to Timestamp Converter - Instant Unix Timestamp Decoder

Last updated March 22, 2026

Platform Epoch Reference

• Twitter: 1288834974657 ms (2010-11-04 01:42:54 UTC)
• Discord: 1420070400000 ms (2015-01-01 00:00:00 UTC)
• Instagram: 1314220021721 ms (2011-08-25 00:00:21 UTC)
• Mastodon: 0 ms (uses Unix epoch directly)

All conversion happens entirely in your browser. Your Snowflake IDs are never transmitted to any server.

Understanding Unix Timestamps

Unix timestamps represent time as the number of milliseconds (or seconds) since January 1, 1970, 00:00:00 UTC (the Unix epoch). This format is universal across programming languages and databases, making it ideal for storing and comparing times.

Milliseconds vs Seconds: JavaScript and many modern APIs use milliseconds (13 digits), while traditional Unix systems use seconds (10 digits). Our converter provides both formats for maximum compatibility.

Code Examples

const snowflakeId = 1382350606417817604n;
const twitterEpoch = 1288834974657n;
const timestamp = (snowflakeId >> 22n) + twitterEpoch;
console.log(Number(timestamp)); // 1618592259657

// Convert to Date
const date = new Date(Number(timestamp));
console.log(date.toISOString()); // 2021-04-16T18:30:59.657Z

snowflake_id = 1382350606417817604
twitter_epoch = 1288834974657
timestamp = (snowflake_id >> 22) + twitter_epoch
print(timestamp)  # 1618592259657

# Convert to datetime
from datetime import datetime
date = datetime.fromtimestamp(timestamp / 1000)
print(date.isoformat())  # 2021-04-16T18:30:59.657000

How Snowflake IDs Work

Snowflake IDs are 64-bit integers that encode multiple pieces of information. The timestamp occupies the first 42 bits (after right-shifting by 22), providing millisecond precision for approximately 139 years from the epoch.

Common Errors & Solutions

Performance & Best Practices

const ids = ['1382350606417817604', '1383000000000000000'];
const timestamps = ids.map(id => 
    Number((BigInt(id) >> 22n) + 1288834974657n)
);

const EPOCHS = {
    TWITTER: 1288834974657n,
    DISCORD: 1420070400000n,
    INSTAGRAM: 0n
};

const timestamp = (BigInt(id) >> 22n) + EPOCHS.TWITTER;

function validateSnowflake(id) {
    if (!/^\d{15,19}$/.test(id)) {
        throw new Error('Invalid snowflake ID');
    }
    return true;
}

Common Use Cases

• Tweet Timestamp Extraction: Get exact posting time from tweet IDs for analytics
• Discord Message Timing: Extract message timestamps for moderation logs
• Instagram Post Analysis: Determine posting patterns from media IDs
• Data Migration: Convert IDs to timestamps when moving between systems
• API Rate Limiting: Calculate request timing from snowflake IDs
• Audit Trails: Build chronological event logs from ID sequences

Try These Real Examples

Frequently Asked Questions

What's the difference between milliseconds and seconds timestamps?

Milliseconds timestamps have 13 digits and provide millisecond precision (used by JavaScript, Discord, Twitter). Seconds timestamps have 10 digits and provide second precision (traditional Unix systems). Divide milliseconds by 1000 to get seconds.

Can I convert timestamps back to snowflake IDs?

Not exactly. While you can create a snowflake ID from a timestamp, you can't recreate the original ID because it also contains worker ID and sequence number. Use our Snowflake Generator to create new IDs.

Why do I need to select a platform?

Each platform uses a different epoch (starting point). Twitter's epoch is 2010, Discord's is 2015, Instagram uses 1970. Selecting the wrong platform will give you an incorrect timestamp by years.

What if my timestamp looks wrong?

Try a different platform option. If the ID is from Twitter but you selected Discord, the timestamp will be off by ~4 years. The correct platform will show a reasonable date.

Related Tools

Input: 1529877576591609861
Platform: Twitter (epoch: 1288834974657 ms)

Calculation:
  1529877576591609861 >> 22 = 364745825466
  364745825466 + 1288834974657 = 1653580800123 ms

Output:
  ISO 8601:    2022-05-26T18:00:00.123Z
  UTC:         2022-05-26 18:00:00.123 UTC
  Unix (ms):   1653580800123
  Unix (s):    1653580800
  Relative:    about 2 years ago

Input: 175928847299117063
Platform: Discord (epoch: 1420070400000 ms)

Calculation:
  175928847299117063 >> 22 = 41943040
  41943040 + 1420070400000 = 1420112343040 ms

Output:
  ISO 8601:    2015-01-01T11:39:03.040Z
  UTC:         2015-01-01 11:39:03.040 UTC
  Unix (ms):   1420112343040
  Account age: ~9 years old (as of 2024)

Input date: 2024-01-01 00:00:00 UTC
Platform: Twitter

Calculation:
  Unix ms: 1704067200000
  1704067200000 - 1288834974657 = 415232225343
  415232225343 << 22 = 1740000000000000000 (approx)

Result: Min Snowflake ID for 2024-01-01 = ~1740000000000000000

Database query using this:
  SELECT * FROM tweets
  WHERE id >= 1740000000000000000;
  -- Returns all tweets from 2024 onwards
  -- Uses primary key index — very fast!