UUID / GUID Generator Online — Free RFC 4122 v4 Generator

Generate one or up to 1000 RFC 4122 v4 UUIDs (also called GUIDs) using the browser native crypto.randomUUID API. Toggle case, hyphens, brackets, quotes, commas — output as hex, Base64, or URL-encoded.

How many?

1 – 1000 per click

Encoding

Hex (RFC 4122 default)Base64 (22 chars)URL-encoded

Format optionsUppercaseHyphensWrap each in "quotes"Comma-separated (instead of newlines)

Brackets

Live preview

550e8400-e29b-41d4-a716-446655440000

Sample output for one UUID with current options

Auto-copy to clipboard on Generate

Generated UUIDs

What is a UUID Generator?

A UUID generator produces 128-bit random identifiers in the canonical 8-4-4-4-12 hex form defined by RFC 4122. UUIDs let independent systems mint identifiers that are statistically guaranteed to never collide — no central counter, no coordination, no race conditions.

This tool is a thin UI on top of crypto.randomUUID(), the browser-native function defined by the WHATWG standard. The result is a real RFC 4122 v4 UUID — bit-for-bit identical to UUIDs produced by Node, .NET Guid.NewGuid, Python uuid.uuid4, and Postgres gen_random_uuid(). Customise the output: case, hyphens, brackets ({}, [], ()), quote-wrapping, comma-separation, plus Base64 or URL-encoded forms.

How to generate UUIDs online — 4 steps

Pick how many. Type a number from 1 to 1000 in the Count field.
Choose format options. Toggle uppercase, hyphens, brackets, quotes, comma-separator. Pick the encoding (hex / Base64 / URL-encoded). The Live preview panel shows what one UUID will look like with your settings.
Click Generate. The browser calls crypto.randomUUID() N times and renders each formatted result in the output panel.
Copy, download, or auto-copy. Hit Copy all, Download as .txt, or enable Auto-copy so the next batch lands on your clipboard the moment you click Generate.

Sample output by format

# Default — lowercase hex with hyphens
550e8400-e29b-41d4-a716-446655440000

# Uppercase, no hyphens
550E8400E29B41D4A716446655440000

# {Braces} + Uppercase (Microsoft GUID style)
{6BA7B810-9DAD-11D1-80B4-00C04FD430C8}

# Quote-wrapped, comma-separated (good for arrays)
"550e8400-e29b-41d4-a716-446655440000", "6ba7b810-9dad-11d1-80b4-00c04fd430c8"

# Base64 (22 chars instead of 36)
VQ6EAOKbQdSnFkRmVUQAAA==

# URL-encoded with braces (safe in query strings)
%7B550e8400-e29b-41d4-a716-446655440000%7D

Format option reference

Option	Effect	Best for
`Uppercase`	Hex digits become A-F instead of a-f	Legacy systems, Microsoft tooling
`Hyphens`	Add or strip the four standard hyphens	URL paths, S3 keys (off)
`Brackets`	Wrap with {}, [], or ()	Microsoft GUID = {}, JS array = []
`Quotes`	Wrap each UUID in double quotes	JSON arrays, SQL inserts
`Commas`	Join with `, ` instead of newlines	One-line arrays, IN clauses
`Base64`	128 bits as 22 chars (24 with padding)	Compact storage, URL params
`URL-encoded`	Percent-encode brackets/quotes	Query strings with brackets

Native crypto.randomUUID

Wraps the browser native UUID v4 function — the same primitive used by Node 19+, Deno, and Bun. No third-party UUID library shipped to your browser.

Every Format Option

Case, hyphens, brackets, quotes, commas, Base64, URL-encoded — toggle independently. Live preview updates as you change settings.

Bulk + Auto-Copy

Generate up to 1000 UUIDs per click. Enable Auto-copy and the next batch lands on your clipboard the moment you click Generate.

Common use cases

check_circlePrimary keys for distributed databases (DynamoDB, Cassandra, CosmosDB)
check_circlePublic IDs for REST/GraphQL resources to avoid leaking row counts
check_circleIdempotency keys for POST endpoints (Stripe, Square, payment APIs)
check_circleCorrelation IDs for distributed tracing across microservices
check_circleS3 object keys, GCS blob names, and Azure Blob path components
check_circleTest fixture IDs and database seed scripts that re-run safely
check_circleDraft IDs created client-side before persisting (offline-first apps)
check_circleMicrosoft COM/.NET interop where {brace-wrapped} GUIDs are required

UUID v4 vs v6/v7 — which version does this tool produce?

This generator produces v4 exclusively, because that is the only version exposed by crypto.randomUUID(). v4 is fully random, which makes it ideal as a public identifier (no information leaks) but suboptimal as a B-tree primary key — random inserts cause page splits and bloat. If you index UUIDs as primary keys at scale, generate v7 server-side (it is time-ordered: leading bits are a millisecond timestamp, trailing bits are random) so insert order matches arrival order. Postgres 18 ships uuidv7(); Node has the uuid package v9+; .NET 9 added Guid.CreateVersion7().

Need other random and identifier generators?

Pair UUIDs with the rest of OpenFormatter's browser-side generators — passwords, hashes, and random integers, all generated locally.

Password Generator Hash Generator Random Number Generator

Frequently Asked Questions

What is a UUID v4?

A UUID v4 is a 128-bit random identifier defined by RFC 4122. The string form is 36 characters: 8-4-4-4-12 hex digits with hyphens, e.g. 550e8400-e29b-41d4-a716-446655440000. Of those 128 bits, 122 are random and 6 encode the version (4) and variant (RFC 4122). It is the universally used UUID flavour for application-generated IDs.

Are these UUIDs RFC 4122 compliant?

Yes. The generator uses crypto.randomUUID(), which the WHATWG specification defines as producing a UUID v4 in the RFC 4122 variant, with version (4) and variant (10xx) bits set correctly. Output is byte-identical to UUIDs produced by Node.js crypto.randomUUID, .NET Guid.NewGuid, Python uuid.uuid4, or PostgreSQL gen_random_uuid().

What is the difference between a UUID and a GUID?

They are the same thing under different names. UUID (Universally Unique Identifier) is the IETF/ISO term used by RFC 4122, the JVM, Python, and Linux. GUID (Globally Unique Identifier) is the Microsoft term used by .NET, COM, the Windows registry, and SQL Server. Both refer to a 128-bit identifier in the same format. Microsoft tooling tends to print them in {brace-wrapped} form — toggle the {} bracket option above to match.

Can I generate UUID v1, v6, or v7?

Not from this tool. The browser native crypto.randomUUID API only produces v4. v1 (timestamp + MAC) is privacy-sensitive and rarely worth implementing client-side. v6 and v7 (time-ordered UUIDs) are useful as primary keys for B-tree-friendly insertion order — generate them in your backend (Node uuid v9+, Postgres uuidv7 extension, .NET Guid.CreateVersion7) where time ordering is meaningful.

How does Base64 UUID encoding work?

A standard UUID is 16 raw bytes (128 bits). Base64 encodes those 16 bytes into 22 characters (24 with padding "=="). Base64 UUIDs save 14 characters versus the canonical 36-char hex form and are URL-safe enough for most uses. Note: standard Base64 uses + and / which are NOT URL-safe; use the URL-encoded option for query parameters.

What is the collision probability for UUID v4?

With 122 random bits, you would need to generate roughly 2.7 × 10^18 UUIDs before there is a 50% chance of a single collision (the birthday bound is ~sqrt(2^122)). Practically, applications generating millions of UUIDs per day for centuries will not collide. Treat UUID v4 as collision-free for any realistic workload.

How many UUIDs can I generate at once?

Up to 1000 per click. The generator runs synchronously in the main thread; 1000 invocations of crypto.randomUUID complete in a few milliseconds even on low-end devices. For batches larger than 1000 (e.g. seeding a million-row test table) generate them in your backend or a Web Worker — the browser is the wrong tool for that scale.

When should I use a UUID vs an incremental ID?

Use UUIDs when IDs are generated client-side or across multiple services without coordination, when exposing IDs in URLs would leak business metrics (incremental IDs disclose row counts), or when merging databases. Use incremental BIGINT IDs when you need the smallest possible storage, fastest B-tree inserts, and IDs are only ever generated by a single primary database. Many systems use both — UUID as the public ID, BIGINT as the storage key.