ModernUUID Icon ModernUUID
RFC 4122 & RFC 9562 SHA-1 STANDARD

UUID v5 Generator (Deterministic SHA-1 Name Hash)

Version 5 is the recommended standard for deterministic name-based identifiers, superseding Version 3 by utilizing the stronger SHA-1 cryptographic hash digest algorithm to convert namespaces and strings into uniform 128-bit IDs.

Select Identifier Architecture
DETERMINISTIC SHA-1 HASH

Online UUID Version 5 Generator Tool

Deterministic name-based identifier generated via SHA-1 hashing of a target namespace and string value.

Generated Output:
Generatingโ€ฆ
Formatting & Manipulation Options
๐Ÿ”ง Hashed Name & Namespace Parameters (UUID v3 & v5)

Deterministic SHA-1 Namespace Hashing Architecture

Standard Reference: IETF RFC 4122 ยง4.3 / RFC 9562 ยง5.5 (Name-Based UUIDs using SHA-1)

160-Bit SHA-1 Digest Truncation & Bit Masking

A standard cryptographic SHA-1 algorithm outputs 160 bits (20 bytes) of hashed data, whereas standard UUID architecture requires precisely 128 bits (16 bytes).

Per RFC 4122/9562 specifications, Version 5 algorithms strictly utilize octets 0 through 15 (the first 16 bytes) of the SHA-1 digest, discarding the trailing 4 bytes (octets 16โ€“19). The algorithm then enforces the Version 5 and Variant 1 bitmasks:

Version 5 Bitmask time_hi_and_version[0] = (digest[6] & 0x0f) | 0x50

Forces the 13th hexadecimal character to always be 5.

Variant 1 Bitmask clock_seq_hi_and_reserved = (digest[8] & 0x3f) | 0x80

Forces the 17th hexadecimal character to always be 8, 9, a, or b.

Distributed Systems Use Cases: Idempotency & Deduplication

๐Ÿ”„ API Idempotency Keys

Construct deterministic transaction IDs from customer ID + order sequence without risking duplicate database billing.

๐Ÿ—„๏ธ Cross-Database Sync

Assign identical universal primary keys to records synchronized across isolated CRM, analytics, and operational databases.

๐ŸŒ URL & Asset Indexing

Convert arbitrary media URLs and file paths into uniform 16-byte database primary keys without collisions.

Multi-Language Code Implementation

// TypeScript / Node.js (uuid package)
import { v5 as uuidv5 } from 'uuid';

// Predefined DNS Namespace
const MY_DNS_NAMESPACE = uuidv5.DNS;

// Generate deterministic UUID v5 from domain:
const siteId = uuidv5('modernuuid.com', MY_DNS_NAMESPACE);
console.log(siteId);
// Always outputs identical UUID across all systems!
// Python (standard library uuid module)
import uuid

# Predefined DNS Namespace
dns_ns = uuid.NAMESPACE_DNS

# Generate reproducible UUID v5:
v5_id = uuid.uuid5(dns_ns, 'modernuuid.com')
print(f"UUID v5: {v5_id}")
๐Ÿš€ HIGH-SPEED BATCH

Bulk Identifier Generation

Generate up to 50,000 unique identifiers simultaneously. Export instantly to Plain Text (`.txt`), JSON Arrays (`.json`), or CSV Column (`.csv`).

items
Previewing generated batch: 10 generated
Developer FAQ & Technical Reference

Frequently Asked Questions

Deep technical explanations covering identifier architecture, token security, cryptographic hashing, and zero-backend client execution.

UUIDs & Identifiers

RFC 9562 & NanoID
01. What is a UUID and what does UUID stand for? +

UUID stands for Universally Unique Identifier (often used interchangeably with GUID, or Globally Unique Identifier). It is a standardized 128-bit algorithmic label formatted as a 36-character hexadecimal string separated by hyphens (e.g., 550e8400-e29b-41d4-a716-446655440000).

As standardized under RFC 9562 (which supersedes RFC 4122), UUIDs empower distributed systems, microservices, and databases to generate uniquely identifying primary keys locally without requiring network synchronization, consensus verification, or a centralized identifier generation authority.

02. What is the difference between UUID v4 and UUID v7? +

The core architectural difference lies in randomness versus time-sortability:

  • UUID v4 is purely pseudo-random, relying entirely on 122 bits of cryptographically secure pseudo-random number generator (CSPRNG) entropy. While completely unpredictable, inserting random v4 keys into relational database engines causes severe B-tree index fragmentation and page splits at massive scales.
  • UUID v7 introduces a revolutionary time-sequential format. It encodes a 48-bit UNIX millisecond timestamp in the most significant bits, followed by monotonic sequence counters and random entropy.

Engineering Recommendation: Deploy UUID v7 for relational database primary keys (PostgreSQL, MySQL, CockroachDB) to maintain lightning-fast chronological B-tree insert indexing, and deploy UUID v4 for transient session authentication IDs, secure bearer tokens, or API secret keys where unpredictability is essential.

03. Can UUIDs collide? Is a UUID completely unique? +

In theoretical mathematics, yes; in practical engineering reality, no. A UUID v4 contains 122 bits of independent entropic variance, creating a total keyspace of 2122 (approx. 5.3 ร— 1036, or 5.3 undecillion) possible combinations.

According to the cryptographic birthday paradox, a system would need to generate approximately 2.71 quintillion UUIDs before reaching a modest 50% probability of a single collision occurring. When generated using hardware-backed operating system entropy (such as the browser native window.crypto.getRandomValues() interface utilized strictly by Modern UUID), cryptographic collision is considered mathematically negligible in production infrastructure.

04. What is a NanoID, and NanoID vs UUID: which is better? +

NanoID is an ultra-compact, URL-safe, high-speed unique identifier generation protocol. When evaluating NanoID vs UUID for architectural integration:

  • Payload Size & Alphabet: NanoID defaults to a concise 21-character representation by harnessing a larger 64-character alphabet (A-Za-z0-9_-). This renders NanoID ~40% smaller than a standard 36-character UUID string while guaranteeing identical cryptographic collision resistance.
  • Execution Performance: NanoID is optimized for rapid hardware memory allocation and CPU efficiency, making it ideal for high-frequency short link URL routing, JSON packet transmission compaction, and NoSQL document keys.
  • Standardization: UUID is explicitly governed by IETF specification protocols (RFC 9562), making it the universal choice for traditional SQL schemas, enterprise RPC contracts, and cross-language interoperability.

Ready to execute these cryptographic utilities locally?

Run multi-format UUID generators, JWT decoders, Bcrypt hashers, and Token synthesis engines inside your browser sandboxโ€”zero server latency, total anti-interception privacy.

Developer Knowledge & Standards

Specifications & Multi-Language Code Snippets.

Integrate UUID version 4, time-ordered version 7 (RFC 9562), and compact NanoIDs directly into your backend or frontend microservices with native, dependency-free code.

generator-snippets.ts
          
        

๐Ÿ“Š Identifier Architecture Matrix

Version Entropy / Logic Ideal Use Case
UUID v4 122 bits random General API keys & universal IDs.
UUID v7 48b time + 74b rand Database Primary Keys (B-Tree sort).
NanoID 126 bits (21 char) URL slugs & tight payloads.
UUID v3/5 MD5 / SHA-1 Hash Deterministic IDs from strings/URLs.
UUID v1 100ns time + MAC Legacy systems requiring MAC audit.
Why use UUID v7 over v4 for databases?

Standard random UUID v4 inserts cause random disk page I/O fragmentation in SQL indexes. Version 7 embeds a chronological millisecond timestamp in the top 48 bits, keeping index inserts naturally sequentially sorted!