Loading tool...
Generate universally unique identifiers (UUIDs) in v4 format with our free UUID Generator, perfect for database primary keys, API tokens, session IDs, and any application requiring globally unique identifiers. UUIDs are 128-bit numbers designed to be globally unique across all systems without centralized coordination—with UUID v4, the probability of generating a duplicate is astronomically low, making them ideal for distributed systems where unique IDs must be generated independently on different machines. This tool generates cryptographically secure random UUIDs using the Web Crypto API, ensuring true randomness suitable for security-sensitive applications. Whether you're designing databases where auto-increment IDs aren't suitable, building distributed systems needing unique request identifiers, creating session tokens for authentication, generating temporary file names, or implementing any system requiring unique identifiers, UUID generation is essential. The tool supports multiple formats including standard hyphenated format (8-4-4-4-12), compact no-dash format for storage efficiency, and case options. Batch generation lets you create multiple UUIDs at once for bulk operations, and one-click copy functionality makes integration into your systems effortless.
Use UUIDs as primary keys in databases where auto-increment IDs could collide or where data merging from multiple systems requires guaranteed uniqueness.
Generate unique request IDs for API calls to track requests through system logs, correlate responses, and debug issues across microservices architectures.
Create secure session tokens and authentication identifiers that are globally unique and cryptographically random, impossible to guess or predict.
Generate unique file names for temporary files, cache entries, and scratch data that won't collide with other processes or systems.
Generate unique object identifiers that can be created independently on different machines and systems without coordination, essential for distributed applications.
Create unique identifiers for transactions, documents, and records in multi-system environments where unique tracking across systems is essential.
A Universally Unique Identifier (UUID) is a 128-bit label used to identify information in computer systems with a guarantee of uniqueness that requires no central coordination authority. The concept was originally created for the Apollo Network Computing System in the 1980s and later standardized as RFC 4122 by the Internet Engineering Task Force (IETF) in 2005, with an updated specification in RFC 9562 published in 2024.
The standard UUID format is a 36-character string consisting of 32 hexadecimal digits displayed in five groups separated by hyphens: 8-4-4-4-12 (e.g., 550e8400-e29b-41d4-a716-446655440000). Despite appearing as a text string, it represents a 128-bit binary number. Two specific bits are reserved to indicate the UUID variant (the encoding scheme), and four bits indicate the version (the generation algorithm), leaving 122 bits for the actual identifier content in the most common Version 4 format.
The UUID specification defines several versions, each using a different strategy for ensuring uniqueness. Version 1 combines a 60-bit timestamp (measured in 100-nanosecond intervals since October 15, 1582—the date of the Gregorian calendar reform) with a 48-bit node identifier, typically the MAC address of the generating machine. This guarantees uniqueness across time and space but reveals the creation time and generating machine, which can be a privacy concern. Version 2 is a DCE Security variant rarely used in practice.
Version 3 and Version 5 are name-based UUIDs that generate deterministic identifiers by hashing a namespace and name. Version 3 uses MD5 hashing while Version 5 uses SHA-1. Given the same namespace and name, these versions always produce the same UUID, making them ideal for generating reproducible identifiers from meaningful names—for example, generating a UUID from a URL or domain name.
Version 4, the most widely used version, generates UUIDs using random or pseudo-random numbers. With 122 bits of randomness, there are approximately 5.3 × 10³⁶ possible Version 4 UUIDs. To put this staggering number in perspective, if you generated one billion UUIDs per second, it would take approximately 100 billion years (about seven times the current age of the universe) to have a 50% probability of generating a single duplicate. In practical terms, generating 103 trillion Version 4 UUIDs gives a one-in-a-billion chance of a single collision.
More recently, Version 7 UUIDs (defined in RFC 9562) have gained significant traction. They embed a Unix timestamp in milliseconds in the most significant 48 bits, followed by random data. This design provides time-ordering, meaning UUIDs sort chronologically, which dramatically improves database index performance compared to the random ordering of Version 4. Many database experts now recommend Version 7 for new applications requiring sortable, time-aware unique identifiers.
UUIDs have become fundamental infrastructure in modern software. Databases like PostgreSQL have native UUID types with optimized storage and indexing. Distributed systems use UUIDs to identify records that may be created on any node without risking collisions. Microservices architectures use UUIDs as correlation IDs to trace requests across service boundaries. File systems, session management, message queues, and countless other systems rely on UUIDs as the universal solution to the problem of generating unique identifiers without central coordination.
UUID v4 uses 122 random bits, giving about 5.3 x 10^36 possible values. The probability of a collision is astronomically low - you would need to generate 2.7 quintillion UUIDs to have a 50% chance of a single duplicate.
UUID v1 is based on timestamp and MAC address. UUID v4 (generated here) uses random numbers and is most commonly used. UUID v5 uses SHA-1 hashing of a name and namespace. V4 is recommended for most applications due to its simplicity and privacy.
Yes, UUIDs work well as primary keys, especially in distributed systems where auto-increment IDs could collide. However, they use more storage (16 bytes vs 4-8 for integers) and may impact index performance in some databases.
Yes, this tool uses the Web Crypto API (crypto.getRandomValues) which provides cryptographically secure random numbers, making the generated UUIDs suitable for security-sensitive applications like session tokens.
All processing happens directly in your browser. Your files never leave your device and are never uploaded to any server.