Generate RFC 4122-compliant UUIDs and GUIDs instantly in your browser. Bulk generation up to 1,000, custom formatting, prefix/suffix, and one-click CSV or TXT download — no sign-up required.
A UUID (Universally Unique Identifier), also called a GUID (Globally Unique Identifier), is a 128-bit number used to uniquely identify information in computer systems. Defined in RFC 4122, a UUID is represented as a 32-character hexadecimal string divided into five groups by hyphens, following the pattern xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx (8-4-4-4-12). For example: 550e8400-e29b-41d4-a716-446655440000
The core advantage of UUIDs is that they can be generated independently on any system — without a central authority or coordination — and still be practically guaranteed unique. The probability of generating two identical UUID v4 values, for example, is approximately 1 in 5.3 × 10³⁶. For all practical purposes in software development, database design, and distributed systems, this collision probability is negligible.
UUID vs GUID: These two terms refer to the same concept. UUID is the standard term used in the RFC 4122 specification and is prevalent in Linux, macOS, Java, Python, Node.js, and most open-source ecosystems. GUID (Globally Unique Identifier) is Microsoft's term for the same standard, used in Windows, .NET, C#, Microsoft SQL Server, and Azure. Both produce the same 128-bit, hyphen-separated format.
All UUIDs generated by this tool are produced entirely in your browser and are fully RFC 4122-compliant. No data is sent to any server.
The UUID standard defines multiple versions, each with a different generation algorithm and use case. Our generator supports v1, v3, v4, and v5. Here is a complete breakdown:
UUID v1 is generated using the current timestamp (a 60-bit value based on 100-nanosecond intervals since October 15, 1582) combined with the MAC address of the generating machine (or a random node ID if the MAC is unavailable).
Best for: event logs, audit trails, time-ordered database records
UUID v3 generates a deterministic UUID by hashing a namespace UUID combined with a name string using the MD5 hash algorithm. The same namespace + name always produces the exact same UUID, making it reproducible and collision-free within a given namespace.
Best for: legacy systems, URL/DNS namespace mapping
UUID v4 is generated using cryptographically random numbers, with only 6 bits reserved for version and variant information. The result is 122 bits of randomness, making it overwhelmingly unlikely that any two generated UUIDs will ever match.
Best for: database primary keys, session tokens, API keys, entity IDs
UUID v5 works identically to v3 — deterministic output from a namespace + name — but uses SHA-1 hashing instead of MD5. SHA-1 is a stronger hash function, making v5 the recommended choice over v3 for all new name-based UUID use cases.
Best for: deriving stable IDs from emails, URLs, usernames, or external identifiers
550E8400-E29B-41D4-A716-446655440000). Toggle Remove hyphens to strip the delimiter dashes and produce a compact 32-character hex string (e.g., 550e8400e29b41d4a716446655440000).user with separator _ produces user_550e8400-e29b-41d4-a716-446655440000..txt or .csv file.Most online UUID generators only support v4. This tool supports all four RFC 4122 versions with the correct algorithms: time-based (v1), MD5 name-based (v3), random (v4), and SHA-1 name-based (v5). Switch versions instantly without reloading.
Generate anywhere from 1 to 1,000 UUIDs in a single batch. Essential for seeding databases, populating test fixtures, generating bulk API keys, or mass-creating entity records in any application.
Toggle uppercase output for systems that require capitalized hex. Remove hyphens to generate compact 32-character strings — useful for database columns that don't support punctuation, storage optimization, or URL-safe identifiers.
Wrap every UUID with a custom prefix (e.g., order_), suffix (e.g., _v2), and separator. This lets you generate application-ready identifiers that match your exact naming convention without any post-processing.
For v3 and v5 name-based UUIDs, choose from predefined RFC 4122 namespaces (DNS: 6ba7b810..., URL: 6ba7b811...) or enter any custom UUID as your namespace. Enter your name string and generate deterministic, reproducible UUIDs.
Four export options to fit any workflow: copy newline-separated UUIDs for code editors and scripts, copy CSV for spreadsheets, or download as .txt or .csv files for use in database seeders, test harnesses, and import tools.
Every UUID is generated locally in your browser using the JavaScript uuid library backed by the Web Crypto API's cryptographically secure random number generator. Nothing is sent to any server. No account required, no rate limits, no watermarks.
On desktop, drag the divider between the config and results panels to resize them to your preference. The tool adapts fully to mobile, tablet, and desktop screens with a responsive layout.
UUIDs are one of the most commonly used identifiers in software engineering. Here are the primary scenarios where developers reach for a UUID generator:
UUIDs are widely used as primary keys in relational databases (PostgreSQL, MySQL, SQLite) and NoSQL databases (MongoDB, DynamoDB, Firestore). Unlike auto-increment integers, UUID primary keys can be generated client-side, work seamlessly in distributed systems, and don't leak record count information through enumerable IDs.
Public-facing APIs expose UUIDs as resource identifiers instead of sequential integers to prevent enumeration attacks. A URL like /users/550e8400-e29b-41d4-a716-446655440000 reveals nothing about total user count or record order.
QA engineers and developers use bulk UUID generation to populate test databases with realistic-looking IDs. Generate 100–1,000 UUIDs, paste them into a SQL seed file or JSON fixture, and you have a complete test dataset in seconds.
UUID v4's cryptographic randomness makes it suitable as session identifiers, CSRF tokens, password reset tokens, and email confirmation codes where unpredictability is a security requirement. Always use v4 (never v1) for security-sensitive tokens.
In distributed architectures where multiple services or nodes create records independently, UUIDs eliminate the need for a central ID-issuing authority. Each service generates its own globally unique IDs without coordination, preventing collisions across service boundaries.
Cloud storage systems (AWS S3, Google Cloud Storage, Azure Blob) use UUIDs as object keys to prevent collisions when multiple processes upload files simultaneously. UUID-named files also prevent overwriting existing files with the same original filename.
Payment APIs (Stripe, Razorpay) and messaging APIs require an idempotency key per request to prevent duplicate operations. A UUID v4 is the standard choice for idempotency keys — unique per request, simple to generate, and universally accepted.
CMS platforms, feature flag systems, and configuration management tools use UUID v5 to derive stable, deterministic IDs from content slugs, feature names, or configuration keys — ensuring the same logical entity always maps to the same UUID across environments.
A UUID is always represented as a 36-character string of 32 hexadecimal digits and 4 hyphens. The format is:
| Segment | Characters | Bits | Meaning |
|---|---|---|---|
| time_low | 8 | 32 | Low 32 bits of time (v1) or random (v4) |
| time_mid | 4 | 16 | Middle 16 bits of time (v1) or random (v4) |
| time_hi_and_version | 4 | 16 | High bits of time + version digit (V) — identifies UUID version (1–5) |
| clock_seq | 4 | 16 | Clock sequence + variant bits (N) — N is 8, 9, a, or b for RFC 4122 |
| node | 12 | 48 | MAC address (v1) or random bits (v4) |
Reading the version: Look at the 13th character (first digit of the third group). A 4 means UUID v4, a 1 means v1, and so on. This is how UUID validator tools identify the version of any given UUID string.
| Format | Length | Sortable | URL-Safe | Collision Resistance | Best For |
|---|---|---|---|---|---|
| UUID v4 | 36 chars | No | Yes | Excellent | DB keys, APIs, tokens |
| UUID v1 | 36 chars | Yes | Yes | Excellent | Logs, time-ordered events |
| ULID | 26 chars | Yes | Yes | Excellent | Modern DBs needing sortable IDs |
| NanoID | 21 chars | No | Yes | Excellent | Short URL IDs, compact keys |
| Auto-Increment INT | 1–10 chars | Yes | Yes | None (enumerable) | Simple single-DB apps |
| MongoDB ObjectId | 24 chars | Yes | Yes | Good | MongoDB collections |
UUID v4 remains the most universally supported and interoperable unique identifier format across all programming languages, databases, and platforms — making it the safe default choice for the vast majority of applications.
Our online UUID generator is ideal for quick, one-off generation. For automated or programmatic generation inside your application, here is how to generate UUIDs in the most common languages:
import { v4 as uuidv4 } from 'uuid';
const id = uuidv4();
// e.g. '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'import uuid
id = uuid.uuid4()
print(str(id))
# e.g. '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d'import java.util.UUID;
UUID id = UUID.randomUUID();
String idStr = id.toString();using System;
Guid id = Guid.NewGuid();
string idStr = id.ToString();// Using ramsey/uuid package
use RamseyUuidUuid;
$uuid = Uuid::uuid4()->toString();-- Generate UUID in PostgreSQL
SELECT gen_random_uuid();
-- Or with pgcrypto extension:
SELECT uuid_generate_v4();For one-off UUIDs during development, testing, database migrations, configuration files, or manual record creation, this online UUID generator is the fastest option — no code to write, no package to install.
UUIDs are used to uniquely identify records, entities, files, sessions, and resources in software systems without a central authority. Common uses include database primary keys, REST API resource IDs, session tokens, idempotency keys, test data generation, and distributed system identifiers where multiple nodes create records independently.
Use v4 for most general-purpose use cases — it is random, widely supported, and safe. Use v1 when you need chronological ordering (e.g., log events, audit trails). Use v5 (preferred over v3) when you need a deterministic UUID derived from a fixed input like a username, URL, or email address.
Yes — GUID (Globally Unique Identifier) and UUID are the same thing. GUID is Microsoft's name for the RFC 4122 UUID standard and is the terminology used in .NET, C#, Windows, and Microsoft SQL Server. UUID is the term used everywhere else. Both produce the same 128-bit, hyphenated hex string format.
Technically, UUID v4 collisions are possible but astronomically unlikely. With 122 bits of randomness, you would need to generate approximately 2.71 quintillion UUIDs to reach a 50% probability of a single collision. In practice, UUID v4 is treated as universally unique for all real-world applications.
A standard UUID has four hyphen separators, producing a 36-character string. Removing hyphens yields a compact 32-character hex string: 550e8400e29b41d4a716446655440000. This format is used when the storage layer doesn't support hyphens, to save 4 bytes per record, or when the identifier must be URL-safe without encoding.
A namespace is itself a UUID that scopes the name-based generation. RFC 4122 defines standard namespaces: DNS (for domain names) and URL (for URLs). Using different namespaces with the same name produces different UUIDs — preventing collisions across different naming systems. You can also define a custom namespace UUID for your own application's identifier space.
UUID v4 uses the browser's Web Crypto API (crypto.getRandomValues()) for cryptographically secure random number generation. This makes it suitable for session tokens, CSRF tokens, and non-cryptographic secret uses. However, for cryptographic secrets like API private keys or encryption keys, purpose-built key generation tools are recommended — UUIDs have only 122 bits of entropy, which is strong but below the 256-bit standard for cryptographic keys.
Set the "How many" field to your desired count (up to 1,000), click Generate, then click "Download .txt" for a newline-separated file or "Download .csv" for a comma-separated file. Both are ready to use in SQL seed scripts, JSON fixtures, Postman collections, or any bulk-import workflow.
Yes. UUID v4 values contain only hexadecimal characters (0–9, a–f) and hyphens, all of which are URL-safe without encoding. They reveal no information about your data structure, are not sequential, and cannot be enumerated — making them safe and recommended for use as public-facing resource identifiers in REST APIs.
Both v3 and v5 are name-based and deterministic. The difference is the hash algorithm: v3 uses MD5, while v5 uses SHA-1. SHA-1 produces a better distribution and is considered more secure than MD5. For all new projects requiring name-based UUIDs, use v5. v3 exists for backward compatibility with older systems.