UUID Generator & Validator

A UUID (Universally Unique Identifier) is a 128-bit value used to label information without a central authority. It is standardized in RFC 9562 (which obsoletes RFC 4122) and is normally written as 32 hexadecimal digits in a 8-4-4-4-12 pattern, for example 550e8400-e29b-41d4-a716-446655440000. Because any system can generate one independently and still expect it to be unique, UUIDs are ideal for distributed systems, databases, and APIs.

This free UUID generator and GUID generator creates identifiers instantly in your browser. Pick a version — UUID v4 (random) by default, or UUID v7 (time-ordered) — and click Generate. Need many at once? The bulk generator produces up to 10,000 UUIDs and exports them as TXT, CSV, or JSON. It is built for developers: backend, full-stack, API, .NET/C#, Java, JavaScript, and TypeScript engineers, plus database and DevOps folks.

A GUID(Globally Unique Identifier) is Microsoft’s term for the same 128-bit identifier. In .NET it is represented by the System.Guid type and created with Guid.NewGuid(). When a .NET developer talks about a GUID, they almost always mean a UUID.

UUID stands for Universally Unique Identifier; GUID stands for Globally Unique Identifier. In most software-development contexts they refer to the same 128-bit identifier format, though terminology varies between ecosystems:

• UUID — used in RFCs, standards, and cross-platform development.
• GUID — used throughout the Microsoft/.NET ecosystem.

Guid id = Guid.NewGuid();
Console.WriteLine(id); // e.g. 550e8400-e29b-41d4-a716-446655440000

UUID v7 can improve database index locality because new IDs sort near each other, but it does not automatically improve performance in every system — measure for your workload before assuming a win.

A UUID is 128 bits, commonly shown as 32 hexadecimal characters in five groups. Two special positions carry metadata:

xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx
              │    │
              │    └── N: variant bits
              └─────── M: version number

M is the version (for example 4 or 7) and the high bits of N identify the variant. For UUID v4, those version and variant bits are fixed and the remaining bits come from random data.

550e8400-e29b-41d4-a716-446655440000
│        │    │    │    │
│        │    │    │    └── 12 hex characters
│        │    │    └─────── 4 hex characters
│        │    └──────────── 4 hex characters
│        └───────────────── 4 hex characters
└────────────────────────── 8 hex characters

1. Select a version (UUID v4 by default).
2. Click Generate UUID (or press Ctrl/⌘ + Enter).
3. Optionally choose uppercase or remove hyphens for the compact form.
4. Click Copy, or use Generate & copy to do both at once.
5. Need many? Set a quantity and use the bulk generator, then Copy All or download TXT/CSV/JSON.

Switch to Validate mode and paste a UUID in canonical (8-4-4-4-12), compact (32 hex), or braced ({…}) form. The validator reports whether it is valid, its version and variant, the detected format, and its length, and shows the canonical form so you can add hyphens back to a compact value or copy it without hyphens.

In .NET, the Guid type represents a UUID/GUID and is a common choice for unique identifiers:

using System;

// Generate
Guid id = Guid.NewGuid();
Console.WriteLine(id);

// Parse (throws on invalid input)
Guid parsed = Guid.Parse("550e8400-e29b-41d4-a716-446655440000");

// Validate without throwing
if (Guid.TryParse(input, out Guid result))
{
    // result is a valid GUID
}

.NET 9 also adds Guid.CreateVersion7() for time-ordered identifiers.

Modern browsers and Node.js expose a native, secure generator. crypto.randomUUID() returns a cryptographically secure version-4 UUID string — no library required.

const id = crypto.randomUUID();
console.log(id); // "550e8400-e29b-41d4-a716-446655440000"

const id: string = crypto.randomUUID();
// id is a UUID v4 string

Prefer the native API over old Math.random()-based snippets, which are neither secure nor guaranteed to be well-formed.

UUIDs are widely used as identifiers in data systems:

• Primary keys and external/public IDs
• Distributed systems and microservices
• API resource identifiers
• Correlation, request, event, and message IDs

UUIDs let independent services generate identifiers without coordination. There are trade-offs, though: random UUIDs (v4) can hurt index locality and increase page splits compared with sequential integers, and they use more storage than a 32-bit or 64-bit key. Time-ordered UUID v7 addresses some of the locality concerns. UUIDs are not automatically better than auto-increment integers — choose based on your access patterns and scale.

• Database records and primary keys
• API resource identifiers
• Distributed systems and microservices
• File and object identifiers
• Request correlation, event, and message IDs
• Testing and development fixtures

Be careful using UUIDs as session identifiers: a UUID should not automatically replace a dedicated, securely generated session-token mechanism with proper expiry and storage.

UUIDs are identifiers, not passwords or authentication secrets. A UUID v4 generated from a secure random source (as this tool does) is unpredictable and fine for generating hard-to-guess identifiers, but a UUID should not automatically be treated as a security token or secret.

Do not use a UUID as a replacement for:

• Authentication or authorization
• API keys
• Passwords or password hashes
• Cryptographic secrets

Yes — your UUIDs are generated locally in your browser. SR Tools does not need to upload your UUIDs or input to generate or validate them. Nothing you generate or paste is sent to a backend, logged, stored in localStorage by default, sent to analytics, or added to the URL. Only your preferences (version and formatting options) are remembered locally on your device.

What is a UUID?

A UUID (Universally Unique Identifier) is a 128-bit identifier, standardized in RFC 9562 (which obsoletes RFC 4122). It is usually written as 36 characters: 32 hexadecimal digits in a 8-4-4-4-12 pattern separated by hyphens, e.g. 550e8400-e29b-41d4-a716-446655440000.

What is a GUID?

GUID (Globally Unique Identifier) is Microsoft's name for the same 128-bit identifier. In the .NET ecosystem the type is System.Guid. For most purposes UUID and GUID refer to the same thing.

Are UUID and GUID the same?

In practice, yes — they describe the same 128-bit identifier format. 'UUID' is the term used in RFCs and cross-platform standards; 'GUID' is common in Microsoft/.NET contexts. Occasionally GUID is used loosely, but the canonical format is identical.

How do I generate a UUID?

Choose your version (UUID v4 by default) and click Generate UUID — a new UUID appears instantly. Use Generate & copy to also place it on your clipboard, or the bulk generator to create many at once. Everything runs locally in your browser.

What is UUID v4?

UUID version 4 is generated almost entirely from random data, with a few bits reserved to mark the version and variant. It is the most common UUID type because it needs no coordination — any node can generate one independently. This tool uses a cryptographically secure random source.

What is UUID v7?

UUID version 7 embeds a 48-bit Unix millisecond timestamp followed by random bits, so v7 values are time-ordered. This can improve locality in database indexes compared to fully random v4 values, while still being globally unique.

Which UUID version should I use?

Use UUID v4 for general-purpose unique identifiers where ordering doesn't matter. Consider UUID v7 when you want identifiers that sort by creation time (for example as database primary keys). Neither is universally 'better' — it depends on your use case.

How long is a UUID?

A UUID is 128 bits. In canonical text form it is 36 characters (32 hex digits plus 4 hyphens); without hyphens it is 32 characters.

How many UUIDs can exist?

The UUID space is 128 bits, or 2^128 ≈ 3.4 × 10^38 possible values. UUID v4 fixes a few bits for the version and variant, leaving 122 random bits (about 5.3 × 10^36 possibilities).

Can UUIDs collide?

A collision is theoretically possible but, for properly generated random UUIDs, extraordinarily unlikely — you would need to generate an astronomical number before a collision became probable. No random identifier system should be described as mathematically impossible to collide, though.

Are UUIDs secure?

UUIDs are identifiers, not secrets. A v4 UUID from a secure random source is unpredictable, but a UUID should not automatically be treated as a security token, API key, or password. Use dedicated mechanisms for authentication and secrets.

How do I generate a UUID in C#?

Use Guid.NewGuid(), which returns a new GUID (equivalent to a random UUID). Parse existing values with Guid.Parse or Guid.TryParse. .NET 9 also adds Guid.CreateVersion7() for time-ordered UUIDs.

How do I generate a UUID in JavaScript?

Use crypto.randomUUID(), which returns a cryptographically secure version-4 UUID string in modern browsers and Node.js. Avoid outdated Math.random()-based implementations.

Can I generate multiple UUIDs?

Yes. The bulk generator creates up to 10,000 UUIDs at once, reports how many are unique within the batch, and lets you copy them or download as TXT, CSV, or JSON.

Can I validate a UUID?

Yes. Switch to Validate mode, paste a UUID (canonical, compact, or braced), and the tool reports whether it is valid, its version and variant, the detected format, and the canonical form.

Can I remove UUID hyphens?

Yes. Enable 'Remove hyphens' in Generate mode to get the compact 32-character form, or use the 'No hyphens' copy option in the validator. You can also add hyphens back by validating a compact UUID and copying its canonical form.

Working with encoded data? Try the Base64 Encoder & Decoder. Formatting SQL? Use the SQL Formatter.