UUID v4 vs v7: Format, Ordering and When to Use Each

Bit layout from RFC 9562

In the text form, the version is the first hex digit of the third group and the variant is the first hex digit of the fourth group (8, 9, a or b for the 10 variant). A regex for v4 therefore looks like ^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$; for v7 replace the 4 with 7.

Node.js: v4 is built in, v7 is 12 lines

crypto.randomUUID() returns a v4. The v7 generator below fills 16 random bytes, overwrites the first six with the millisecond timestamp, then forces the version nibble to 7 and the two variant bits to 10. The test generates three IDs two milliseconds apart and confirms they sort in generation order:

import { randomUUID, getRandomValues } from 'node:crypto';

console.log('v4:', randomUUID());

function uuidv7() {
  const bytes = new Uint8Array(16);
  getRandomValues(bytes);
  const ts = BigInt(Date.now());                          // 48-bit unix_ts_ms
  for (let i = 0; i < 6; i++) bytes[i] = Number((ts >> BigInt(8 * (5 - i))) & 0xffn);
  bytes[6] = (bytes[6] & 0x0f) | 0x70;                    // version 7 in the high nibble
  bytes[8] = (bytes[8] & 0x3f) | 0x80;                    // variant 10xxxxxx
  const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
  return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
}

const ids = [];
for (let i = 0; i < 3; i++) { ids.push(uuidv7()); await new Promise(r => setTimeout(r, 2)); }
console.log(ids.join('\n'));
console.log('version nibble:', ids.map(u => u[14]).join(','), ' variant char:', ids.map(u => u[19]).join(','));
console.log('sorted as strings === generation order:', JSON.stringify([...ids].sort()) === JSON.stringify(ids));
console.log('timestamp of first:', new Date(parseInt(ids[0].replace('-', '').slice(0, 12), 16)).toISOString());

// $ node uuid.mjs
// v4: 7cf1cf06-ad98-4d5b-a29e-9c4fe362d082
// 01a0af3a-9bf0-747f-9a38-075ed05afea4
// 01a0af3a-9bf2-79fa-93a8-da0a2327282d
// 01a0af3a-9bf4-7660-a5b6-f6cba519cfdd
// version nibble: 7,7,7  variant char: 9,9,a
// sorted as strings === generation order: true
// timestamp of first: 2026-09-17T11:57:28.944Z

The three v7 values share the prefix 01a0af3a-9bf because they were created within the same few milliseconds; the v4 shares nothing with them. This minimal generator does not guarantee ordering for IDs created inside the same millisecond, RFC 9562 §6.2 describes counter and sub-millisecond techniques for that, and production libraries implement one of them.

Python: uuid4() everywhere, uuid7() from 3.14

import uuid

u = uuid.uuid4()
print("v4:", u, "version", u.version, "variant", u.variant)
print("has uuid7:", hasattr(uuid, "uuid7"))

# $ python3 uuid_test.py   (Python 3.10)
# v4: 1af54d9d-9885-4b25-bd49-47ee8051db63 version 4 variant specified in RFC 4122
# has uuid7: False

The Python documentation adds uuid.uuid7() in version 3.14: it generates “a time-based UUID according to RFC 9562, §5.7” and, for portability across platforms lacking sub-millisecond precision, embeds a 48-bit timestamp and uses a 42-bit counter to guarantee monotonicity within a millisecond. uuid6() and uuid8() arrive in the same release. On 3.13 and earlier, hasattr(uuid, "uuid7") is False and you need a third-party package or a port of the Node function above.

When to use which

Frequently Asked Questions

Related guides

• SQL vs NoSQL: Which Database Is Right for Your Project?
• REST API Design Principles: Best Practices