Random UUIDs Explained: Format, Versions and Uses
Published: 15 November 2026 · by Umar Farooq Iftikhar
Two computers that have never met need to name things without clashing. A database on one continent creates a record while another database, offline, creates a different record, and later the two sets of records merge into one table. If both used counting numbers, both would have a record 1, and the merge would collide. A random UUID solves this by making every identifier so unlikely to repeat that no central registry is needed: each machine mints its own, independently, and the results practically never overlap. The UUID Generator makes them in batches of up to 100, free in your browser, and this guide explains what they are, how to read one, which version you need, and where they go wrong.
A random UUID is a version 4 UUID: 122 bits available for random or pseudorandom data, wrapped in a 36-character format, with 6 bits fixed to announce the version and the variant. The format sets the layout; the random source sets the unpredictability, and the specification recommends a cryptographically secure generator for the job — the version label alone does not guarantee it. This site's generator follows that recommendation, using the browser's cryptographic functions. It contains no timestamp, no machine address and no counter, so it reveals nothing about when or where it was created. That is both its strength and its limit: it is the recommended default for general-purpose identifiers, and the wrong choice when you need ordering, short codes, or secrecy. The sections below work through the format field by field, the real collision odds at realistic scales, the eight versions, and the mistakes that cause trouble later.
Reading a UUID: the 36 characters, field by field
Take this UUID, the example used across many UUID guides: 550e8400-e29b-41d4-a716-446655440000. It is 32 hexadecimal digits — the characters 0 to 9 and a to f — arranged in five groups of 8, 4, 4, 4 and 12 digits, separated by four hyphens. Thirty-two digits plus four hyphens make 36 characters in total. The hyphens carry no information; they exist so the string is readable. The value itself is 128 bits, or 16 bytes: each hexadecimal digit encodes 4 bits, and 32 times 4 is 128.
Two positions in the string carry metadata, and they are the only positions you ever need to read. The first character of the third group is the version: here it is 4, marking a version 4 UUID. The first character of the fourth group is the variant: here it is a, one of the four values 8, 9, a and b that mark the standard variant defined by RFC 9562. Everything else in the string depends on the version: in a version 4 UUID, every other digit is part of the 122-bit payload available for random or pseudorandom data. The standard pattern is written xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, where M is the version digit and N is the variant digit.
A second example shows how much the two positions tell you. The example in RFC 9562 itself is f81d4fae-7dec-11d0-a765-00a0c91e6bf6: the third group starts with 1, so it is a version 1 UUID, built from a timestamp and a node identifier rather than randomness, and the fourth group starts with a, so it uses the same standard variant. Two characters, read in the right places, distinguish a random identifier from a time-based one. The specification still advises treating UUIDs as opaque whenever parsing is unnecessary: most code should compare and store them whole, and read the version only when the version actually matters.
The 6 fixed bits: version and variant
Of the 128 bits, 6 are fixed by the standard and 122 are free. Four bits, at positions 48 to 51, hold the version number: 0100 in binary for version 4, which is why the version digit reads 4. Two bits, at positions 64 and 65, hold the variant: 10 in binary, which is why the fourth group's first digit is always 8, 9, a or b — those four hexadecimal digits all begin with the bits 10. The remaining 122 bits are the payload: in a version 4 UUID, all 122 are available for random or pseudorandom data, and whether the result is unpredictable depends on the generator that fills them.
This is why a version 4 UUID has about 5.3 times 10 to the power of 36 possible values — 2 to the power of 122 — rather than the full 2 to the power of 128. The fixed bits cost almost nothing: 122 payload bits still leave vastly more space than any system will ever use, as the collision section below shows. And it is why checking a UUID's version by eye works: the version digit is not a label stuck on afterwards, it is four bits inside the value itself, placed where every reader agrees to look.
How random is a random UUID?
Random, in this context, has a strict meaning. RFC 9562 says implementations should use a cryptographically secure pseudorandom number generator, a CSPRNG, so that values are both difficult to predict and unlikely to collide. That is a recommendation about how the 122 bits should be produced, not a property of the format itself: the version 4 layout provides 122 bits for random or pseudorandom data, and an implementation that fills them from a weak source still produces a syntactically valid version 4 UUID — just a predictable one. The version digit tells you the layout, not the quality of the randomness. A CSPRNG uses randomness provided through the operating system or platform's cryptographic random-generation facilities, rather than an arithmetic formula with a seed an attacker could guess. The generator on this site follows that rule: on modern browsers it calls crypto.randomUUID(), the browser's built-in CSPRNG-backed version 4 generator, and on older browsers it fills 16 bytes from crypto.getRandomValues() and sets the version and variant bits by hand. Either way the output is a proper version 4 UUID, and neither path ever uses Math.random(), the predictable general-purpose generator that must never be used for identifiers.
What randomness leaves out matters as much as what it puts in. A version 4 UUID has no timestamp, so it does not reveal when it was created; no machine address, so it does not reveal where; and no counter, so consecutive values give no clue how many came before. Older version 1 UUIDs embed a timestamp and a node field: the timestamp generally discloses the generation time it records, though implementations may alter it and it need not be an exact wall-clock record, and the node field, in the traditional form, holds the machine's MAC address, disclosing the generating machine's network hardware — although implementations may instead use a randomly generated node value precisely to avoid exposing a hardware address, as the specification describes. The traditional form is one of the reasons the current specification steers new designs away from version 1. A random UUID is, by design, an identifier that says nothing about its own history.
Random does not mean unguessable in every sense. A properly generated version 4 UUID cannot feasibly be guessed by trying values one by one, but that is not the same as being a secret. The section "A UUID is not a secret" explains the difference, and why it matters.
How likely is a collision, really?
Collisions follow the birthday bound, not the full space. The question is not how many values exist, but how many you must generate before two of them match — the same effect behind the birthday paradox, where 23 people are enough for a better-than-even chance that two share a birthday. For version 4 UUIDs, the usual square-root approximation puts the coin-flip point at about 2 to the power of 61 values, roughly 2.3 quintillion. Generating a billion UUIDs every second, day and night, would take about 73 years to reach that point. Those are the same figures the generator page states, and they are approximations: the more precise birthday formula puts the 50 percent point slightly higher, near 2.7 quintillion. Either way, the scale is quintillions, not millions.
The realistic scales are more useful than the coin-flip point. The chance of even one duplicate among a million generated UUIDs is about 1 in 10 to the power of 25. Among a billion, about 1 in 10 to the power of 19 — one in ten quintillion. Among a trillion, about 1 in 10 to the power of 13. Even a quadrillion UUIDs, a thousand trillion, carries a duplicate chance of only about 1 in 10 million. For the batches this tool makes — tens or hundreds at a time — manually pre-checking each value for duplicates is normally unnecessary. Applications should still enforce uniqueness where it matters, with a database uniqueness constraint on the identifier column, and apply safeguards proportionate to what a collision would cost: a duplicate key in a log file is a different matter from a duplicate key in a safety-critical record. That probability-based guarantee suits identifiers, but when a repeat must be impossible rather than merely unlikely — a lottery line, a raffle draw or a winner list — the mechanism needed is sampling without replacement: each number drawn is removed from the pool, so no number can come up twice.
Two honest caveats. First, the specification itself states that true global uniqueness is impossible to guarantee without a shared-knowledge scheme: UUIDs offer uniqueness for practical purposes, not a mathematical proof, and applications where a collision would be catastrophic must add their own safeguards rather than relying on probability alone. Second, real-world duplicates almost never come from the maths. They come from a weak random source, from the same value copied and pasted into two records, or from a generator bug — failures of implementation, not of arithmetic. A UUID copied twice is a duplicate with certainty, whatever the odds say.
The versions: v1 to v8, and which one you actually meet
The current specification, RFC 9562, published in May 2024 and replacing RFC 4122, defines eight versions. The version number is not a ranking: higher is not automatically better, and each version answers a different need. Two of them carry the choices this guide covers — version 4, the general default, and version 7, the time-ordered option — but knowing what the others encode stops misreading a UUID you find in the wild.
Version 1 is the original time-based UUID: a 60-bit timestamp counting 100-nanosecond intervals since 15 October 1582, plus a clock sequence and a node field. The node field may hold the machine's MAC address, which is the traditional form, but implementations can instead use a randomly generated node value to avoid exposing a hardware address, as the specification describes. A version 1 UUID encodes a timestamp from which its generation time can generally be inferred, although implementations may alter the timestamp, so it is not necessarily an exact record of wall-clock creation time; one built the traditional way also exposes the generating machine's network hardware, and the specification's own motivation section lists that MAC exposure as a privacy and security problem. It sorts roughly by creation time, but the time disclosure alone is reason enough for the specification to steer new designs elsewhere. Version 2 is reserved for DCE Security with embedded POSIX identifiers: a specialized legacy format defined for that ecosystem.
Versions 3 and 5 are name-based and deterministic: the same namespace and the same name always produce the same UUID, because the value is a hash of the namespace identifier concatenated with the name. Version 3 uses MD5 and is kept for compatibility; version 5 uses SHA-1 and remains the interoperable choice where existing systems expect a name-based UUID, because it is the version other implementations recognize. But SHA-1 has known collision weaknesses — distinct inputs can be crafted to produce the same digest — so version 5 must not be treated as a security mechanism: it provides stable, reproducible identifiers, not integrity protection or unforgeability. Where a hash-based identifier must resist deliberate collision attacks, the specification directs new designs to a custom version 8 layout built on a stronger hash such as SHA-256, rather than to version 5. Determinism is the point — a name-based UUID is a stable label for a known thing — but it also means anyone who knows the namespace and the name can recompute the UUID, so name-based values must never be treated as unpredictable. The specification also cautions against using name-based UUIDs as database primary keys, because the name a key derives from can later change.
Version 6 is version 1 with its timestamp fields reordered so the most significant time bits come first, which makes values sort correctly as plain text and improves database-index locality. It exists mainly as a migration path for systems already using version 1: the specification says systems without legacy version 1 should use version 7 instead. Version 8 is reserved for custom, experimental or vendor-specific layouts: the version and variant bits must be set, but the remaining bits mean whatever the defining application says, and uniqueness must not be assumed.
Version 7 is the modern time-ordered version, and the one new designs should consider first when ordering matters. It stores a 48-bit Unix timestamp in milliseconds — the number of milliseconds since 1 January 1970 — in the most significant bits, followed by 74 further bits that implementations may fill with random data, with counters, or with other permitted mechanisms — for example to keep values ordered within a single millisecond — so those 74 bits are not necessarily all random. Values sort by creation time as plain text, with improved entropy characteristics over version 1. The specification says implementations should use version 7 instead of versions 1 and 6 where possible. Two limits apply: a version 7 UUID reveals its approximate creation time to anyone who reads it, and the stored timestamp is a hint rather than proof — implementations are permitted to alter it, clocks can move backwards, and a sorted key is not evidence of event order.
This site's generator makes version 4 UUIDs only, whichever browser path runs. There is no version selector, because for the uses the tool serves — general identifiers, test data, request IDs, file names — version 4 is the right default, and offering versions whose semantics a reader has not asked for would invite mistakes. If your system needs version 7, generate it where your data lives: in your database or your application's UUID library, not by reformatting a version 4 value, which would produce a string that looks like version 7 but carries no real timestamp.
v4 or v7: which should you pick?
Choose version 4 when you need a unique identifier and nothing else: no ordering, no determinism, no embedded information. It is the default choice for a general identifier: it needs no clock and no coordination, and it carries no encoded timestamp or node identifier — so, when properly generated, its value gives no clue about its origin. Choose version 7 when the identifier will be a database primary key or must sort by creation time. Random version 4 keys land at random positions in a database index, forcing inserts all over the structure; the specification notes that the index-locality difference between random and time-ordered inserts can be an order of magnitude or more. Time-ordered keys cluster new rows together, which is why version 7 exists.
The trade is information. A version 7 UUID tells anyone who reads it roughly when it was created, which is a privacy consideration for user-facing identifiers and a feature for internal keys. A version 4 UUID tells nothing. If ordering does not matter to your use, version 4's silence is the safer default; if it does, version 7's timestamp is worth the disclosure. What you should not do is treat the choice as cosmetic: switching versions later means re-keying every record that carries the old form, so decide on the basis of how the identifier will be stored and sorted, not on which looks tidier.
Formats: hyphens, braces, capitals, and the urn: prefix
The standard text form is the hex-and-dash string: five groups separated by single hyphens, 8-4-4-4-12. The specification's formal grammar defines exactly that shape, and it is the form parsers expect. Letter case does not matter: the standard explicitly allows all uppercase, all lowercase, or mixed case, so 550E8400-E29B-41D4-A716-446655440000 and 550e8400-e29b-41d4-a716-446655440000 are the same UUID. The generator's Uppercase checkbox exists for systems and import formats that insist on capitals; it changes the presentation, not the value.
Two common variants wrap the same string. Curly braces, as in {550e8400-e29b-41d4-a716-446655440000}, are how some implementations — the specification names Python and Microsoft outputs — present a UUID; the braces are not part of the value, and a parser that expects the plain form may reject them. The URN form prefixes the string with urn:uuid:, giving urn:uuid:550e8400-e29b-41d4-a716-446655440000: the same value expressed as a Uniform Resource Name, used where a URN namespace is required. Removing the hyphens to make a 32-character string is also common in compact storage, but it is not the standard string form: strip hyphens only when the receiving system documents that it expects them gone, and never assume a parser will accept both shapes.
Two special forms deserve a mention because they look like mistakes. The nil UUID, 00000000-0000-0000-0000-000000000000, has all 128 bits set to zero and means "no value here": a placeholder for a UUID field that has not been assigned. The max UUID, FFFFFFFF-FFFF-FFFF-FFFF-FFFFFFFFFFFF, has all bits set to one and serves as an end-of-list sentinel. Neither is a generated identifier, neither carries a version, and both fall outside the standard variant — their fourth groups start with 0 and f respectively, not 8, 9, a or b — which is exactly how a reader knows they are special forms rather than ordinary values.
Where random UUIDs get used
The recurring destinations are the same ones the generator page lists, and each carries its own caveat. As database primary keys, UUIDs let records be created on several machines or offline and merged later without coordination — but random keys scatter across the index, so a high-write table should weigh version 7 instead. As request and correlation IDs, one UUID travels with a transaction through logs across several services, making the whole journey searchable under a single value; here the opacity advice applies, since nobody needs to parse the ID, only to match it.
As names for uploaded files, exports and backups, UUIDs prevent the quiet disaster of overwriting a same-named file, and their characters — hexadecimal digits and hyphens — are safe in file names on Windows, macOS and Linux. As test and seed data, a hundred realistic identifiers arrive in one paste, which is what the bulk option is for. And as session, device or installation identifiers, UUIDs identify an app instance without exposing a sequential count of users. In every case the value is the same: an identifier minted locally, with no registry to consult and no coordination to wait for.
When a UUID is the wrong choice
A UUID is long and unreadable: 36 characters that no person will read out, type from memory, or spot-check. Anything a human must handle — a booking reference, a short link, a code read over the phone — wants a shorter, friendlier identifier, even at the cost of a central registry to guarantee uniqueness. Length is also a storage cost: as text, a UUID needs 36 characters, which the specification counts as 288 bits to represent a 128-bit value, so databases should store the 16-byte binary form where feasible rather than the text.
Ordering needs rule out version 4, as the versions section explains: if creation order must survive sorting, use version 7 or a time-ordered alternative such as ULID, one of the identifier schemes the RFC 9562 authors analyzed when designing the new versions. Deterministic needs rule out random UUIDs entirely: if the same input must always produce the same identifier, a name-based version 5 UUID is the interoperable choice, not a random one — with the SHA-1 limits noted in the versions section. And secrecy needs rule out UUIDs of every version, which is the next section's subject.
A UUID is not a secret
A version 4 UUID is unguessable in bulk: trying values one by one against 122 bits of properly generated randomness is infeasible, and the specification's unguessability guidance exists precisely so that UUIDs can serve as identifiers nobody can enumerate. But unguessable is not the same as secret. UUIDs are printed in URLs, logs, payloads and database exports by design; they are identifiers, meant to be passed around, and once one leaks, anyone holding it can use it wherever the system accepts it as proof of identity. An ordinary UUID carries no lifecycle controls of its own: no expiry, no revocation list, no authorization policy. An application can revoke or replace an identifier through its own record management — deleting or rotating the stored value — but that machinery belongs to the application, not to the UUID, and every copy of the old value held elsewhere stays usable until the application's records catch up. None of this is a complaint about entropy: 122 properly random bits are ample unpredictability for a bearer token. The gap is lifecycle, not bits.
The practical rule is simple. Use a UUID where you need an identifier, and use a purpose-built credential — a password, an API key, a signed token — where you need authentication or authorization. An "unguessable link" that grants access to whoever holds it is security through obscurity wearing a random number's clothes: it works until the link is shared, logged, or indexed, and then it fails completely. The same applies to password-reset tokens and session cookies: generate those with your framework's credential machinery, which handles expiry and revocation, not with a UUID generator.
How to use the UUID generator
The workflow is short. Set how many you need — from 1 to 100, defaulting to 5 — tick Uppercase if your system wants capitals, and click Generate UUIDs. The values appear one per line, with a Copy all button that puts the whole batch on your clipboard in exactly the shape seed scripts and SQL inserts want. Generation happens on click, not live as you type, and every click makes a fresh batch of newly random values. If you need more than 100, generate again and paste the batches together.
Two behaviours are worth knowing before you rely on them. First, the tool keeps no history: generation runs entirely in your browser through its cryptographic functions, nothing is transmitted or stored anywhere, and nobody — including this site — can retrieve a UUID you generated. Copy the batch before you close the tab. Second, the tool makes version 4 UUIDs only, in the standard hyphenated form, with the uppercase option as its only format choice. There is no version selector, no brace or hyphenless output, and no validation of UUIDs you paste in: it generates, and that is all it claims to do.
Mistakes that cause trouble later
- Treating a UUID as a secret: an unguessable identifier in a URL is not access control. Use proper credentials where authentication matters, and assume any UUID in a log or link is public.
- Sorting version 4 UUIDs and expecting creation order: random values sort randomly. If order matters, the identifier must carry time — version 7, or a time-ordered alternative — from the start.
- Stripping hyphens, adding braces, or changing case without checking the parser: the standard form is hyphenated, case does not matter, but braces and hyphenless forms are variants a strict parser may reject. Match the form your system documents.
- Using a name-based UUID as a database primary key: the name it derives from can change — a postal code, a product code, a username — and changing the key invalidates the structure built on it. The specification cautions against exactly this.
- Generating UUIDs with Math.random() in your own code: it is predictable and unfit for identifiers. Use crypto.randomUUID() in JavaScript, uuid.uuid4() in Python, or your platform's equivalent.
- Reading a version 7 timestamp as proof of event order: implementations may alter timestamps, clocks move backwards, and a sorted key is not evidence that one event preceded another. Keep separate records where order must be proven.
- Copying one UUID into two records and assuming the odds protect you: a pasted duplicate is a duplicate with certainty. Generate a fresh value for every record that needs its own identity.
Conclusion
A random version 4 UUID is a small, solved problem: 122 bits available for random or pseudorandom data, six fixed bits that say what it is, and a 36-character wrapper that any implementation following the standard can read. Minting one needs no registry and no coordination with any other machine, which is why version 4 turns up everywhere from database keys to file names — provided the bits come from a sound random source, as the specification recommends. Its limits are equally plain: no ordering, no determinism, no secrecy, and no meaning beyond identity. Other versions trade away some of that silence for ordering or determinism: version 7 is time-ordered, and versions 3 and 5 are deterministic. Used inside those limits — version 4 for general identifiers, version 7 where time order matters, proper credentials where security matters — it is one of the most reliable building blocks in software. Generate a batch on the UUID Generator and the format will feel familiar within minutes.
Sources
1. IETF, RFC 9562: Universally Unique IDentifiers (UUIDs) — https://www.rfc-editor.org/info/rfc9562/ — the current UUID standard (May 2024, obsoletes RFC 4122): 128-bit format, hex-and-dash string form, variant and version fields, versions 1–8, nil and max UUIDs, collision resistance, unguessability, sorting and database guidance. Sections relied on: 2.1 (update motivation, including MAC-address privacy), 4–4.2 (format, string form, variant and version fields), 5.1 and 5.4–5.10 (version layouts, nil and max UUIDs), 6.1–6.2 (timestamp considerations, monotonicity), 6.7–6.10 (collision resistance, uniqueness, unguessability, non-identifying nodes), 6.11–6.13 (sorting, opacity, database considerations), 8 (security considerations). Sections listed read 15 November 2026.
2. MDN Web Docs, Crypto: randomUUID() method — https://developer.mozilla.org/en-US/docs/Web/API/Crypto/randomUUID — generates a v4 UUID using a cryptographically secure random number generator; returns a 36-character string; secure contexts only. Accessed 15 November 2026.
3. Python Software Foundation, uuid — UUID objects according to RFC 4122 (Python 3.11 documentation) — https://docs.python.org/3.11/library/uuid.html — uuid.uuid4() function definition; getnode() random-node fallback with the multicast bit set; uuid3()/uuid5() MD5/SHA-1 name-based definitions. Implementation check: CPython Lib/uuid.py defines uuid4() as UUID(bytes=os.urandom(16), version=4). Accessed 15 November 2026.
4. Oracle, UUID (Java SE 21 and JDK 21) — https://docs.oracle.com/en/java/javase/21/docs/api/java.base/java/util/UUID.html — randomUUID() method: static factory for a type 4 (pseudo randomly generated) UUID, generated using a cryptographically strong pseudo random number generator; node() field description. Accessed 15 November 2026.
5. ULID Specification (canonical spec) — https://github.com/ulid/spec — 26-character canonical string in Crockford Base32 against the 36-character UUID; 48-bit Unix-millisecond timestamp plus 80 bits of randomness; lexicographic sorting with same-millisecond order not guaranteed; monotonicity by incrementing the random component. Accessed 15 November 2026.
Frequently asked questions
Should I use UUID v7 instead of v4?
Use v4 unless you need ordering. Version 4 is the default for general identifiers: it carries no encoded timestamp and no node identifier, needs no clock, and — when properly generated — its value gives no clue about its origin. Its unpredictability depends on proper random generation: the version label alone does not guarantee it. Version 7 is the better choice when the identifier will be a database primary key or must sort by creation time, because its leading timestamp keeps new rows clustered in the index. The trade is disclosure: a v7 UUID reveals its approximate creation time to anyone who reads it. This site's generator makes version 4 only; for v7, check your database's or language's UUID support.
What is the nil UUID, and when would I see one?
The nil UUID is 00000000-0000-0000-0000-000000000000: all 128 bits set to zero. It is a reserved special form meaning "no value here", used as a placeholder in a field that requires a UUID but has not been assigned one. You will see it in database rows, API responses and configuration files as an explicit empty value. It is not a generated identifier, it carries no version, and you should never generate it as an ID: its fourth group starts with 0, outside the standard variant, which is how readers know it is a placeholder rather than an ordinary value.
Do UUIDs need hyphens, braces or the urn: prefix?
The standard text form uses hyphens: five groups, 8-4-4-4-12, separated by single hyphens, and that is the form parsers expect. Braces and the urn:uuid: prefix are presentation variants for particular contexts — some tools output braces, and the URN form is used where a URN namespace is required — but neither is part of the value itself. Letter case never matters: uppercase, lowercase and mixed case are all the same UUID. A hyphenless 32-character string is not the standard form, so only strip hyphens when the receiving system documents that it expects them gone.
Can I use a UUID as an API key or password?
No. A version 4 UUID is unguessable by brute force, but it is an identifier, not a credential: UUIDs appear in URLs, logs and payloads by design, and once one leaks, anyone holding it can use it wherever the system accepts it. That is not a complaint about entropy: a properly generated v4 UUID has ample randomness for a bearer token's unpredictability requirement. The gap is lifecycle: credentials need expiry, rotation and revocation as built-in controls, and an ordinary UUID provides none of those itself. An application can revoke or replace a stored identifier through its own record management, but that machinery belongs to the application, not to the UUID. Use your framework's password hashing and token machinery for authentication, and reserve UUIDs for naming things.
How do I generate a UUID in code?
A built-in call that produces a version 4 UUID exists in JavaScript (crypto.randomUUID()), in Python (uuid.uuid4() from the standard uuid module), and in Java (UUID.randomUUID()). All three use cryptographic randomness. Never build one from Math.random() or another predictable generator: the result looks like a UUID but can be guessed, which defeats the purpose.
What is a ULID, and how is it different from a UUID?
A ULID is a time-ordered identifier that solves the same problem as a UUID but is not a UUID: it combines a 48-bit millisecond timestamp with 80 bits of randomness, written as 26 characters in Crockford Base32, and it sorts by creation time at millisecond granularity — within a single millisecond the order is not guaranteed. Because the format differs, UUID parsers will not accept it. Its specification lives on GitHub rather than as an IETF standard, and it is one of the schemes the authors of RFC 9562 analyzed while designing the new UUID versions. Use a ULID only where your stack supports its format; where a standard UUID is required and ordering matters, version 7 is the equivalent choice within the UUID standard.
Should I store UUIDs as text or as binary?
Binary where feasible: a UUID is 16 bytes, while its 36-character text form needs 288 bits to represent a 128-bit value. Binary storage saves space and may speed up access; text needs no translation when the value is displayed after retrieval. The specification recommends binary storage within database applications where feasible, and text elsewhere as appropriate.
More guides on the QuikTools Hub blog.