Discord Tool

ID Lookup

Decode Discord snowflake IDs to extract creation date, internal IDs, and more. Supports bulk decoding.

Decode Settings

How Discord Snowflakes Work

Discord IDs are 64-bit integers called snowflakes. They encode:

  • Timestamp: First 42 bits (milliseconds since Discord Epoch: 2015-01-01)
  • Worker ID: Next 5 bits (internal worker)
  • Process ID: Next 5 bits (internal process)
  • Increment: Last 12 bits (auto-incrementing)

timestamp = (id >> 22) + 1420070400000

Results

#

Enter a Discord ID to decode

Discord Snowflake IDs: The Complete Guide to ID Lookup and Decoding

Every object in Discord, including users, servers, channels, messages, roles, and emojis, is identified by a unique numeric identifier called a Snowflake ID. These IDs are not random numbers; they are carefully engineered 64-bit integers that encode valuable metadata, most importantly the exact timestamp when the object was created. Understanding how snowflake IDs work gives you a powerful tool for investigating Discord accounts, verifying the age of servers and channels, and building moderation tools that leverage the hidden information embedded in every Discord identifier.

The snowflake system was originally developed by Twitter for generating unique, time-sortable IDs at massive scale. Discord adopted this approach because it provides several critical properties: IDs are generated without coordination between servers, they are chronologically sortable with newer IDs always being larger numbers, and they encode their creation timestamp within the ID itself. These properties make snowflake IDs both efficient for database operations and useful for forensic analysis of Discord accounts and communities, giving anyone with the right tools instant access to creation date information for any Discord entity.

Our Discord ID Lookup tool decodes snowflake IDs instantly, revealing the creation date, internal worker and process IDs, and the auto-incrementing sequence number. Whether you are investigating a suspicious account, auditing server membership dates, or building a moderation bot that needs to check account age, this tool provides immediate access to the metadata hidden inside every Discord identifier without requiring API access or bot permissions.

The Internal Structure of a Snowflake ID

A Discord snowflake is a 64-bit integer divided into four distinct sections, each encoding different information. Understanding this bit-level structure is key to appreciating how Discord generates unique IDs across its distributed infrastructure and how you can extract useful data from any identifier. The total 64 bits are allocated as follows: 42 bits for the timestamp, 5 bits for the worker ID, 5 bits for the process ID, and 12 bits for the increment counter. This design ensures that every ID is globally unique while remaining sortable by creation time.

Snowflake bit breakdown (64 bits total)

Timestamp (42 bits, bits 22-63): The most significant 42 bits store the number of milliseconds since the Discord Epoch (January 1, 2015, 00:00:00 UTC). This gives Discord approximately 69 years of unique timestamps before rollover. To convert a snowflake to a timestamp, right-shift the ID by 22 bits and add the Discord Epoch offset.

Worker ID (5 bits, bits 17-21): These 5 bits identify which Discord server worker generated the ID. With 5 bits, there are 32 possible worker values (0-31), supporting Discord's distributed infrastructure.

Process ID (5 bits, bits 12-16): These 5 bits identify the specific process within the worker that generated the ID, ensuring global uniqueness even when multiple processes generate IDs simultaneously on the same worker.

Increment (12 bits, bits 0-11): The final 12 bits represent an auto-incrementing counter that resets for every millisecond. With 12 bits, Discord can generate up to 4096 unique IDs per process per millisecond, supporting extremely high throughput.

The mathematical formula for extracting the creation timestamp from a snowflake ID is straightforward: timestamp = (snowflake >> 22) + 1420070400000. The result is a Unix timestamp in milliseconds that you can convert to any date format using standard date libraries in any programming language.

Extracting and Interpreting Creation Dates

The most useful piece of information encoded in a snowflake ID is the creation timestamp. For user accounts, this tells you exactly when the account was created. For servers, it reveals the founding date. For channels and roles, it shows when they were added. This information has significant practical value for moderation, investigation, and community management, as it allows you to verify claims about account age, identify recently created suspicious accounts, and establish accurate timelines of events that would otherwise require API access to determine.

What creation dates can tell you

  • Account age verification: Verify whether a user actually joined when they claim. A newly created account claiming to be a long-time member is an immediate red flag for potential deception.
  • Alt account detection: Multiple accounts with similar creation dates, especially recent ones, may indicate ban evasion or coordinated activity targeting your community.
  • Server founding date: A server ID reveals when the server was created, useful for verifying the legitimacy and age of a community before partnering or collaborating.
  • Message timeline reconstruction: Message snowflakes encode when the message was sent, even if the displayed timestamp has been manipulated or edited after the fact.
  • Chronological sorting: Because newer snowflakes are always larger numbers, you can sort any collection of Discord IDs to establish chronological order without additional metadata.

Types of Discord IDs and What They Represent

Discord uses snowflake IDs for virtually every entity in its system, but the structure of the ID doesn't tell you what type of object it represents. A user ID, a guild ID, a channel ID, and a message ID all follow the same snowflake format with the same bit allocation. To determine what type of object an ID corresponds to, you need additional context or a lookup against Discord's API. This universal format simplifies database design and sorting but requires context to interpret correctly.

Common ID Types

  • User IDs: Identify unique Discord accounts, never change
  • Guild/Server IDs: Identify Discord servers globally across the platform
  • Channel IDs: Identify text, voice, and announcement channels
  • Message IDs: Unique per message, chronologically sortable
  • Role IDs: Identify server roles and their permission configurations
  • Emoji IDs: Identify custom server emojis uploaded by members

How to Find IDs

  • • Enable Developer Mode in Discord advanced settings
  • • Right-click any user, channel, or message
  • • Select "Copy ID" from the context menu
  • • IDs are also visible in Discord channel and message URLs
  • • Use the API to resolve IDs to full object representations
  • • Audit logs contain IDs for all referenced entities

When working with Discord IDs in your applications, always store them as strings rather than numbers. Although snowflakes are 64-bit integers, JavaScript's Number type only provides 53 bits of precision, which means large snowflake IDs will lose precision when stored as numbers. Using BigInt or string representations preserves the full ID value and prevents subtle bugs in your application logic.

Bulk ID Decoding for Moderation and Analysis

When managing large Discord communities or investigating coordinated activity, you often need to decode dozens or even hundreds of IDs at once. Manually checking each ID individually is time-consuming and error-prone, which is why our tool includes a dedicated bulk decode mode. Simply paste your IDs, one per line, and the tool will decode all of them simultaneously, presenting the results in an organized format that makes it easy to spot patterns and anomalies across multiple accounts or entities that would be invisible when checking IDs one at a time.

Bulk decoding use cases

  • Ban evasion detection: Decode IDs of recently joined members to identify accounts created within a suspiciously short time window that may indicate coordinated ban evasion.
  • Server audit: Decode channel and role IDs from your server's audit log to build a complete timeline of when server infrastructure was created and modified.
  • Raid analysis: After a raid, bulk decode the IDs of offending users to determine if they were created recently, suggesting they were made specifically for the attack.
  • Membership verification: Cross-reference user IDs with their claimed join dates to verify authenticity and identify accounts that may be misrepresenting their history.

Practical Use Cases for Discord ID Lookup

Discord ID lookup has applications far beyond simple curiosity. Community managers, moderators, developers, and security researchers all use snowflake decoding as part of their daily workflows. Whether you are building moderation tools, investigating suspicious activity, or simply trying to understand your Discord community better, the ability to extract creation dates from IDs is an invaluable capability that provides insights not available through Discord's standard user interface.

For Moderators

  • • Detect newly created alt accounts used for ban evasion
  • • Verify user claims about account age or join date
  • • Identify suspicious patterns in account creation dates
  • • Build timelines of incidents using message snowflake IDs
  • • Audit when channels and roles were created in the server

For Developers

  • • Debug bot interactions by tracing message snowflake IDs
  • • Validate that API responses contain correct entity IDs
  • • Sort database records by creation date using IDs directly
  • • Implement rate limiting based on message timestamps
  • • Build audit logging systems with accurate embedded timestamps

Technical Deep Dive: Snowflake ID Internals

For developers building applications that interact with Discord's API, a deeper understanding of snowflake internals is essential. The snowflake generation algorithm is designed to produce globally unique, chronologically sortable IDs without requiring coordination between different servers or database instances. This is achieved by encoding the worker and process IDs into each snowflake, ensuring that two different processes on two different machines will never generate the same ID even when operating at the exact same millisecond.

Key technical considerations

JavaScript precision: Standard JavaScript numbers use 64-bit floating-point representation with only 53 bits of integer precision. Always use BigInt or string representations when handling Discord IDs in JavaScript to avoid silent precision loss.

Discord Epoch vs. Unix Epoch: Discord's epoch starts on January 1, 2015 (Unix timestamp 1420070400000). To convert a snowflake timestamp to Unix time, add this offset to the extracted timestamp value from the upper bits.

ID validation: A valid snowflake should produce a timestamp between the Discord Epoch and the current time. IDs that decode to dates before 2015 or far in the future are invalid and likely the result of a copy-paste error or corruption.

Increment behavior: The 12-bit increment counter resets each millisecond. If a process generates more than 4096 IDs in a single millisecond, it must wait for the next millisecond before generating additional IDs to maintain uniqueness guarantees.