Every time your application needs to identify a record, resource, or event without asking a central server for the next available number, a UUID (Universally Unique Identifier) is the answer — and the UUID version 1 generator above lets you create one instantly. What makes UUID v1 distinctive is that each value encodes the precise moment it was created alongside the hardware address of the generating machine, giving you a timestamp-based UUID that carries its own chronological context.
UUID Structure: The 8-4-4-4-12 Format
A UUID is a 128-bit label — stored as 16 bytes — represented as 32 hexadecimal characters arranged in five groups separated by hyphens, the canonical 8-4-4-4-12 pattern:
xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
A real example: 6ba7b810-9dad-11d1-80b4-00c04fd430c8. Here M is the version indicator (the digit "1" for a Version 1 UUID) and N encodes the variant bits. The structure is governed by RFC 4122 (2005) and its successor RFC 9562 (2024). To generate uuid v4 quickly and privately — no data ever leaves your browser — use the UUID v4 Generator.
Anatomy of a Version 1 UUID
A version 1 UUID packs three distinct components into its 128 bits. Using 6ba7b810-9dad-11d1-80b4-00c04fd430c8 as an example:
- Time-low field (
6ba7b810): the least significant 32 bits of the 60-bit UTC time-value, measured in 100-nanosecond intervals since October 15, 1582 - Time-mid field (
9dad): the next 16 bits of the same time-value - Time-high-and-version field (
11d1): the most significant 12 bits of the time-value, plus 4 version bits set to "0001" — the leading "1" confirms this is version 1 - Clock sequence (
80b4): a counter incremented when the clock is set backwards or the node address changes, preventing duplicate output - Node field (
00c04fd430c8): the 48-bit hardware network interface address — the component that anchors uniqueness to a specific machine
Because the time-value sits at 100-nanosecond resolution, UUIDs created in sequence sort roughly into chronological order — a property a fully random UUID cannot offer.
How Unique Is a UUID v1?
Unlike UUID v4, which draws uniqueness from 122 random bits, a UUID v1's uniqueness comes from a different source: the current time-value combined with the host's node identifier. Because the time resolution is fine enough (100-nanosecond intervals) and the clock-sequence field guards against clock rollbacks, duplicates remain extraordinarily unlikely as long as clocks are properly managed — even across many machines generating values simultaneously. Retrieve the nil uuid for use as a default foreign key, null reference, or initial state in your schema.
| Version | Description | Best Use Case |
|---|---|---|
| UUID v1 | Timestamp + node-based (time and MAC address) | Time-ordered IDs, event logs, audit trails |
| UUID v4 | Random, 122 bits of entropy | General-purpose IDs — usually the best starting point |
| UUID v5 | Name-based, hashed with SHA-1 | Deterministic, application-defined namespace IDs |
| UUID v7 | Unix timestamp + random data | Modern sortable IDs, preferred for new database primary keys |
When to Choose UUID v1 Over v4 or v7
| Feature | UUID v1 | UUID v4 | UUID v7 |
|---|---|---|---|
| Randomness | None (deterministic) | 122 random bits | Partial (timestamp + random) |
| Sortability | Partial (field-split) | No | Yes (native sort) |
| Privacy | Exposes node/MAC address | No exposure | Exposes creation time only |
Tip: Choose UUID v1 when you need roughly time-ordered labels and aren't concerned about hardware-address exposure — for example, closed internal pipelines or event-logging systems. Choose UUID v4 for a truly unpredictable value with no timing metadata. Choose UUID v7 when you need sortable UUIDs for modern storage design without exposing hardware details.
UUID v1 in Databases
Every major storage system supports UUID natively or via extension:
- PostgreSQL — native
uuidtype; theuuid-osspextension providesuuid_generate_v1() - MySQL / MariaDB — store as
CHAR(36)orBINARY(16); the built-inUUID()function produces v1-style values - SQL Server —
uniqueidentifiercolumn type, viaNEWID() - Oracle —
RAW(16)orVARCHAR2(36), viaSYS_GUID()
UUID primary keys carry a real tradeoff: higher storage than integer keys and, for fully random v4 values, index fragmentation from arbitrary insert order. UUID v1 partially mitigates this — rows inserted close together share similar time prefixes, reducing fragmentation compared to purely random UUIDs, though UUID v7 improves on this further with a clean sequential prefix.
Debugging with UUID v1's Embedded Timestamp
Because each UUID v1 value embeds a time-value, you can decode the exact creation time from any UUID in your logs or event records — useful for trace correlation across systems without a separate timestamp column. Our UUID Decoder tool extracts it directly.
Frequently Asked Questions
What is a Version 1 UUID?
A Version 1 UUID is a 128-bit universally unique identifier generated using the current timestamp and a node identifier (typically derived from a MAC address or a random value). It is defined by RFC 4122 and encodes time information, making it possible to determine roughly when it was created.
How does Version 1 differ from Version 4?
Version 1 UUIDs are generated using the current timestamp and a node identifier, so they contain temporal information. Version 4 UUIDs are generated entirely from random numbers. Version 1 can reveal when and potentially where a UUID was created, while Version 4 carries no such information.
Is a Version 1 UUID truly unique?
Yes, for all practical purposes. The combination of a high-resolution timestamp and a unique node identifier makes the probability of two Version 1 UUIDs colliding astronomically small, provided clocks are properly managed.
What are common use cases for Version 1 UUIDs?
Version 1 UUIDs are commonly used in distributed databases, event logging, and systems where the creation time of an identifier is useful. Because they are roughly time-ordered, they can be more index-friendly than fully random UUIDs.
Can I use Version 1 UUIDs as database primary keys?
Yes. UUIDs are widely used as primary keys in relational and NoSQL databases because they can be generated independently without a central authority. Version 1 UUIDs have the added benefit of being roughly time-sortable, which partially reduces the index fragmentation seen with fully random UUIDs.