Chronological locality
Later leading timestamps place new values near other recent values. RFC 9562 explains that time-ordered UUIDs can improve index locality compared with inserts at random positions.
48-bit Unix milliseconds · RFC 9562 · Local CSPRNG
Create time-ordered UUID version 7 identifiers, generate lexically increasing batches, and decode the embedded millisecond timestamp. Every value is produced and inspected in this browser tab.
017f22e2-79b0-7cc3-98c4-dc0c0c07398f
└─ Unix ms └v7 └ RFC variant
2022-02-22T19:22:22.000ZRFC 9562 Appendix A.6 vector
Sortable ID workspace
The first 48 bits encode Unix epoch milliseconds in network byte order. Generate one value or a batch, then use the adjacent inspector to confirm version, variant, normalized standard text, and UTC time.
Loading the UUID v7 generator…
Enable JavaScript to generate time-ordered UUIDs and decode their timestamps.
The modern time-ordered layout
UUID version 7 is a 128-bit identifier layout standardized by RFC 9562. Its most significant 48 bits contain an unsigned count of milliseconds since 1970-01-01 00:00:00 UTC, excluding leap seconds. The version field consumes four bits, the RFC variant consumes two, and 74 remaining bits provide randomness or carefully defined monotonic fields plus randomness.
Putting time first makes UUID v7 values sortable as opaque bytes and as standard hyphenated text. Values created in later milliseconds compare after earlier values without rearranging the fields. That property is useful for database indexes, event streams, logs, and other systems that want decentralized identifiers but prefer chronological locality over the random insertion pattern of UUID v4.
UUID v7 does not replace a timestamp column. The embedded time describes UUID generation, may reflect an inaccurate or deliberately altered system clock, has only millisecond precision in its standard leading field, and lacks business meaning such as “created after validation.” Keep explicit application timestamps whenever the distinction matters.
0111.10 for the RFC layout.48 + 4 + 12 + 2 + 62
The RFC test vector makes each field concrete without relying on a library-specific object layout.
unix_ts_ms · 48 bits017F22E279B0Decimal 1645557742000, or .ver · 4 bits7The version nibble at the first character of the third hyphenated group.rand_a · 12 bitsCC3Random data in the appendix vector; an implementation may instead use approved monotonic subfields.var · 2 bits10The RFC variant. The visible fourth group begins with 9, one of 8, 9, A, or B.rand_b · 62 bits18C4DC0C0C07398FThe two highest bits belong to the variant; the remaining 62 supply random payload in this vector.The final test value is 017F22E2-79B0-7CC3-98C4-DC0C0C07398F. Uppercase and lowercase are both valid hexadecimal presentation. LiveParse normalizes inspected values to lowercase standard text so comparisons are predictable.
Time ordered is not automatically strict order
A basic conforming UUID v7 implementation may fill all 74 non-version and non-variant payload bits with fresh random data. The timestamp makes values ordered across different milliseconds, but random suffixes do not guarantee that two IDs generated during the same millisecond appear in creation order. Calling every UUID v7 generator “strictly monotonic” is therefore inaccurate.
RFC 9562 describes optional methods for additional monotonicity. An implementation can put a fixed-length counter immediately after the timestamp, use a randomly seeded monotonic value, or replace up to 12 leading random bits with additional clock precision. Counters require state, clock rollback handling, overflow behavior, and enough capacity for the maximum generation rate. A generator must not knowingly return duplicates after counter rollover.
LiveParse keeps state inside each requested batch. It seeds a fixed 14-bit counter from the browser cryptography source, places that counter immediately after the timestamp across rand_a and the first two available rand_b bits, and fills the remaining 60 bits with fresh cryptographic randomness for every value. The counter advances when multiple values use the same effective millisecond. If the clock would move backward during that batch, the generator retains the last effective millisecond before advancing the counter. The output is therefore lexically increasing within that one batch. Separate page loads, tabs, devices, and application processes do not share that state, so this page does not claim a global total order.
Values returned by one click are strictly increasing in the text order displayed. It does not coordinate with another browser tab or another UUID generator. Distributed systems should define ordering, collision handling, and persistence constraints at the system boundary.
Inspect an existing UUID v7 →Useful locality, workload-specific results
Later leading timestamps place new values near other recent values. RFC 9562 explains that time-ordered UUIDs can improve index locality compared with inserts at random positions.
When available, store the underlying 128-bit value in a native UUID or binary type rather than 36-character text. Confirm your database’s comparison order and driver byte mapping.
Application nodes can mint UUIDs without a central sequence allocator. Still enforce a unique key and define what the application does if insertion reports a conflict.
Index type, fill factor, row size, write concurrency, replication, storage engine, and cache behavior all influence results. Do not promise a speed multiplier without testing the actual schema and workload.
Decode without confusing trust
Remove presentation syntax and read the first twelve hexadecimal digits as one unsigned 48-bit integer. That integer is Unix milliseconds. For the RFC vector, 017f22e279b0 equals 1645557742000. Converting that value to UTC produces 2022-02-22T19:22:22.000Z.
The LiveParse inspector performs that extraction only after parsing the complete UUID, identifying the RFC variant, and finding version 7. A string that merely begins with twelve hex digits is not enough. Strict input mode requires the ordinary 8-4-4-4-12 text form; normalize mode can unwrap braces, a case-insensitive urn:uuid: prefix, or a compact 32-digit value before inspection.
Extracted time is evidence about the bits, not proof about the event that produced them. A generator can have a wrong clock, an application can import an old ID later, and an attacker can construct any UUID bits. Do not authorize, bill, expire, or order security-sensitive events solely from an untrusted UUID timestamp.
10 variant for RFC 9562 versions.7.Ordering versus opacity
UUID v7 is not a universal upgrade. Version 4 does not intentionally reveal generation time and is widely supported in runtimes, databases, validation libraries, and existing schemas. RFC 9562’s security considerations recommend v4 for security work involving UUIDs because time-based identifiers expose timing and ordering information. That still does not make every v4 value an authorization token.
Choose v4 when opaque random placement is acceptable, timestamp disclosure is undesirable, or interoperability requires v4. Choose v7 when a new system benefits from chronological ordering and you have evaluated its information exposure. A migration can affect comparison semantics, indexes, application validators, database defaults, ORM types, API documentation, fixtures, and downstream consumers.
Both versions remain 128-bit UUIDs and use the same standard text width. The key decision is not which string looks newer; it is whether time order or opacity better matches the data model. The UUID v4 vs v7 guide provides a fuller decision checklist.
The main UUID generator defaults to UUID v4 and supports the same bulk, GUID presentation, JSON, SQL, copy, download, and validation options.
Open UUID Generator →Know what the value reveals
Anyone who receives a normal UUID v7 can extract its leading millisecond timestamp. Do not describe it as an opaque value when that timing metadata matters.
Nearby time-ordered IDs can disclose approximate creation sequence or traffic timing. Authorization must prevent enumeration from becoming data access.
Timestamp bits do not provide uniqueness by themselves. LiveParse fills payload state from the browser cryptography API and never falls back to Math.random().
No generated or pasted UUID is submitted to a conversion endpoint. Clipboard managers, downloads, extensions, and other device software remain outside the page’s processing boundary.
Questions answered
Yes. The IETF published UUID v7 in RFC 9562 in May 2024. That RFC obsoletes RFC 4122, retains earlier UUID versions, and defines versions 6, 7, and 8 plus updated best practices.
No. A conforming implementation may use random data throughout the 74 available payload bits, which does not guarantee creation order within the same millisecond. Strict monotonic behavior requires one of the stateful approaches described in RFC 9562 Section 6.2 and correct overflow and clock handling.
The most significant 48 bits contain unsigned Unix epoch milliseconds, excluding leap seconds. It is a generation-time field, not an authenticated business timestamp.
RFC 9562 designs v7 for byte and lexicographic ordering in the standard text representation. Compare consistently normalized forms. Extra wrappers, different case, or nonstandard database byte transformations can affect an application’s comparison behavior.
Leading time order places recent values near each other in an index instead of scattering inserts across random positions. Actual performance depends on the database, index, row shape, workload, concurrency, and configuration, so benchmark rather than assuming a fixed improvement.
You can recover the 48-bit millisecond value, but it reflects the generator clock and not necessarily the database commit, validation, ingestion, or business-event time. Keep an explicit trusted timestamp for those meanings.
They use different layouts, and collision analysis depends on generation method, volume, nodes, and failure impact. Neither provides an absolute global guarantee. Use sound libraries, secure random sources, unique constraints, and conflict handling.
No. Its timestamp is visible, and UUID structure does not define authentication, scope, expiration, rotation, revocation, or authorization. Use a purpose-built token mechanism and server-side access checks.
No. Generation and inspection run in the current browser tab. The page itself must load normally, but UUID input and output are not posted to a generator API or stored in a LiveParse database.