Qu'est-ce qu'un UUID ? Format, versions et UUID vs GUID

Un UUID (universally unique identifier, identifiant unique universel) est un nombre de 128 bits qui sert à identifier des données sans demander à un serveur central le prochain identifiant libre. On l'écrit généralement sur 36 caractères : 32 chiffres hexadécimaux répartis en cinq groupes 8-4-4-4-12, par exemple f47ac10b-58cc-4372-a567-0e02b2c3d479. Le format est défini par la RFC 9562 (mai 2024), qui remplace la RFC 4122.

Essayez gratuitement : Générateur d'UUID Gratuit, sans création de compte.

Qu'est-ce qu'un UUID apporte concrètement ? N'importe quel système peut en créer un seul, hors ligne, tout en étant pratiquement certain que personne d'autre ne produira jamais la même valeur. C'est pourquoi les UUID servent de clés de base de données, de noms de fichiers, d'identifiants de requêtes et de messages. Ce guide explique le format, les versions, le vrai risque de collision, la différence entre UUID et GUID, et comment choisir entre v4 et v7. Pour tester les exemples, ouvrez le générateur d'UUID gratuit dans un autre onglet.

Qu'est-ce qu'un UUID, concrètement ? Le format 8-4-4-4-12

Les 128 bits font 16 octets. Chaque octet s'écrit avec deux chiffres hexadécimaux, soit 32 chiffres, et quatre tirets portent la forme texte à 36 caractères. Deux positions ont un sens fixe :

f47ac10b-58cc-4372-a567-0e02b2c3d479
              ^    ^
              |    +-- 17e chiffre "a" : variante (8, 9, a ou b = RFC 9562)
              +------- 13e chiffre "4" : version 4 (aléatoire)

• La version est le premier chiffre du troisième groupe (le 13e chiffre hexadécimal). Elle indique comment l'UUID a été créé.
• La variante est le premier chiffre du quatrième groupe (le 17e chiffre hexadécimal). Pour les UUID standard, ses deux bits de poids fort valent 10, donc ce chiffre est toujours 8, 9, a ou b. Les valeurs 0 à 7 appartiennent aux anciens identifiants NCS, c et d sont réservés à la rétrocompatibilité Microsoft, et e et f à un usage futur.

Comme ces 6 bits sont fixes, un UUID aléatoire de version 4 contient 128 − 6 = 122 bits aléatoires. Les lettres hexadécimales peuvent être en majuscules, en minuscules ou mélangées : F47AC10B-… et f47ac10b-… sont le même UUID ; les minuscules restent la convention la plus courante.

Les versions d'UUID : de v1 à v8, nil et max

La RFC 9562 définit huit versions et deux valeurs spéciales :

Les versions basées sur un nom sont déterministes. L'espace de noms DNS avec le nom example.com donne toujours l'UUID v5 cfbff0d1-9375-5685-968c-48ce8b15ae17, sur n'importe quelle machine et dans n'importe quel langage. Utilisez-les quand une même entrée doit toujours correspondre au même identifiant.

Un UUID de version 7 place le temps en tête. Cet exemple a été créé le 24/09/2026 à 12:00:00 UTC, soit 1 790 251 200 000 millisecondes après l'époque Unix, ou 0x01a0d3496e00 en hexadécimal :

01a0d349-6e00-7c3f-9d21-4b6e8a1f0c57
^^^^^^^^^^^^^ ^    ^
|             |    +-- chiffre de variante "9"
|             +------- version 7
+--------------------- horodatage de 48 bits en ms

Les 74 bits restants sont aléatoires (ou en partie un compteur, selon la bibliothèque).

Les UUID sont-ils uniques ? Le risque de collision en v4

L'unicité des UUID n'est pas garantie : elle est seulement extrêmement probable. Avec 122 bits aléatoires, il existe 2^122 ≈ 5,3 × 10^36 valeurs v4 possibles. L'approximation du paradoxe des anniversaires donne le nombre n d'UUID nécessaire pour avoir 50 % de chances qu'au moins deux soient identiques :

n ≈ √(2 · ln 2 · 2^122) ≈ 2,71 × 10^18

Cela fait 2,71 trillions d'UUID. À un milliard par seconde, il faudrait environ 86 ans pour les atteindre. Pour des volumes réalistes, le risque est négligeable :

Ces chiffres supposent un bon générateur aléatoire. En pratique, les collisions viennent de bogues : un générateur mal initialisé, des machines virtuelles clonées qui réutilisent le même état, ou du code qui copie un identifiant au lieu d'en créer un nouveau. Une contrainte d'unicité dans la base reste donc utile.

UUID vs GUID : quelle différence ?

En pratique, aucune. GUID (globally unique identifier) est le nom que Microsoft donne à la même valeur de 128 bits, utilisée dans Windows, COM, .NET et SQL Server. Par exemple, Guid.NewGuid() de .NET crée un UUID de version 4 tout à fait ordinaire. Les différences portent sur la présentation et le stockage :

• L'écriture. Les outils Microsoft affichent souvent les GUID en majuscules et entre accolades, comme {F47AC10B-58CC-4372-A567-0E02B2C3D479}. C'est la même valeur que la forme en minuscules.
• L'ordre des octets en binaire. La structure GUID de Microsoft découpe la valeur en un champ de 32 bits, deux champs de 16 bits et 8 octets isolés. Sur les systèmes little-endian, et dans Guid.ToByteArray() de .NET, les trois premiers champs sont stockés avec leurs octets inversés, tandis que les 8 derniers octets gardent leur ordre. On parle souvent de mixed-endian :

Texte :          f47ac10b-58cc-4372-a567-0e02b2c3d479
Ordre RFC :      f4 7a c1 0b | 58 cc | 43 72 | a5 67 0e 02 b2 c3 d4 79
Microsoft :      0b c1 7a f4 | cc 58 | 72 43 | a5 67 0e 02 b2 c3 d4 79

Le texte est identique ; seuls les 16 octets bruts diffèrent. Si vous copiez des GUID binaires entre un système Microsoft et un système qui attend l'ordre RFC, la valeur ressort brouillée. Passez par la forme texte ou, à partir de .NET 8, utilisez ToByteArray(bigEndian: true). Microsoft décrit les groupes inversés dans la référence de Guid.ToByteArray.

« UUID vs GUID » est donc une question de nom, pas un choix à faire.

UUID v4 ou v7 comme clé primaire

Ce sont deux UUID de 128 bits, mais ils se comportent très différemment dans un index.

• v4 est aléatoire : chaque nouvelle ligne arrive à une position au hasard dans l'index B-tree. Les insertions touchent des pages dans tout l'index, ce qui provoque des divisions de pages, davantage d'écritures et un volume de travail plus grand à garder en mémoire.
• v7 commence par un horodatage : les nouveaux identifiants sont plus grands que les anciens. Les insertions se font en fin d'index, comme avec un entier auto-incrémenté, et les lignes créées ensemble restent groupées.

v7 permet aussi de trier par identifiant pour obtenir l'ordre de création, et de lire la date de création dans l'identifiant. C'est aussi son inconvénient : quiconque voit un identifiant v7 sait quand l'enregistrement a été créé, à la milliseconde près. Utilisez v4 pour les identifiants publics dont la date doit rester privée, et v7 pour les clés internes de grandes tables très sollicitées en écriture.

Stocker les UUID efficacement

Stockez les 16 octets, pas le texte de 36 caractères. Une colonne texte occupe au moins 36 octets par valeur, plus du double, et chaque index qui contient la clé grossit d'autant.

• PostgreSQL : utilisez le type natif uuid (16 octets).
• SQL Server : utilisez uniqueidentifier (16 octets).
• MySQL : utilisez BINARY(16) avec UUID_TO_BIN() et BIN_TO_UUID() pour la conversion.

Ne convertissez en texte qu'aux frontières du système, par exemple dans les API et les journaux.

Générer un UUID dans le code

La plupart des langages intègrent un générateur :

import uuid
uuid.uuid4()                                   # random v4
uuid.uuid7()                                   # v7, Python 3.14+
uuid.uuid5(uuid.NAMESPACE_DNS, "example.com")  # cfbff0d1-9375-5685-968c-48ce8b15ae17

crypto.randomUUID(); // v4, in browsers (HTTPS pages) and Node.js

SELECT gen_random_uuid();  -- v4, built in since PostgreSQL 13
SELECT uuidv7();           -- v7, PostgreSQL 18+

Guid.NewGuid();         // v4
Guid.CreateVersion7();  // v7, .NET 9+

crypto.randomUUID() est documenté sur MDN. Dans le navigateur, il ne fonctionne que sur des pages sécurisées (HTTPS).

Valider un UUID avec une expression régulière

Ce motif accepte la forme canonique des versions 1 à 8 avec la variante standard (sans tenir compte de la casse) :

^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$

[1-8] vérifie le chiffre de version et [89ab] la variante. Ajoutez des contrôles séparés si vous voulez aussi accepter les UUID nil et max, les accolades ou le préfixe urn:uuid:.

Les UUID ne sont pas des secrets

Un UUID identifie quelque chose ; il ne le protège pas. La RFC 9562 précise que les implémentations ne doivent pas supposer que les UUID sont difficiles à deviner et ne doivent pas les utiliser comme mécanisme de sécurité. v1 révèle l'heure de création et, traditionnellement, l'adresse MAC de la machine qui l'a produit ; v7 révèle l'heure de création. Même un v4 issu d'un générateur sûr n'est pas conçu comme jeton de réinitialisation de mot de passe ou clé d'API. Pour cela, utilisez un jeton aléatoire dédié, par exemple avec le générateur de jetons, et vérifiez malgré tout les autorisations à chaque requête.

Alternatives à l'UUID

L'ULID est une alternative répandue aux objectifs proches : 128 bits, un horodatage de 48 bits en millisecondes et 80 bits aléatoires, écrits en 26 caractères Base32 de Crockford pour être triables comme du texte. Si vous avez besoin de ce format, le générateur de ULID crée et décode des ULID et les convertit en UUID. Pour un nouveau projet, l'UUID v7 offre le même tri chronologique tout en gardant le format UUID standard que les bases de données comprennent nativement.

Générer et analyser des UUID en ligne

Le générateur d'UUID gratuit fonctionne entièrement dans votre navigateur. Il crée des UUID v1, v3, v4, v5 et v7 ainsi que les valeurs nil et max, jusqu'à 500 à la fois. Vous pouvez choisir minuscules, majuscules ou accolades, supprimer les tirets et séparer la liste par des retours à la ligne, des virgules, des espaces ou sous forme de tableau JSON, puis la copier ou la télécharger en .txt ou .json. Pour v3 et v5, choisissez l'espace de noms DNS, URL, OID ou X.500, ou collez le vôtre.

Le validateur intégré accepte les formes canonique, entre accolades, urn:uuid: et sans tirets, et affiche la version, la variante et la forme canonique. Il décode l'horodatage des UUID v1 et v7, ainsi que la séquence d'horloge et le nœud des v1. Quelques limites : il ne génère ni v6 ni v8, son v1 utilise un nœud aléatoire au lieu de votre adresse MAC, et les identifiants v7 créés dans la même milliseconde ne sont pas garantis dans l'ordre de création, car les bits qui suivent l'horodatage sont aléatoires et non un compteur.

FAQ

Un UUID est-il la même chose qu'un GUID ?

Oui. GUID est le nom que Microsoft donne à un UUID. La valeur et le format texte sont identiques ; les outils Microsoft affichent souvent les GUID en majuscules entre accolades, et certaines API Microsoft stockent les trois premiers champs en little-endian dans la forme binaire.

Deux UUID peuvent-ils être identiques ?

En théorie oui, en pratique presque jamais. Avec v4, il faudrait environ 2,71 × 10^18 UUID pour avoir 50 % de chances d'un doublon. Les vrais doublons viennent généralement de bogues logiciels ou d'un générateur aléatoire défaillant : gardez donc une contrainte d'unicité sur les colonnes de clé.

Faut-il choisir UUID v4 ou v7 ?

Choisissez v7 pour les clés primaires de tables avec beaucoup d'insertions, car des identifiants ordonnés dans le temps gardent les index compacts et se trient par date de création. Choisissez v4 quand l'identifiant est public et ne doit rien révéler de sa date de création.

Quelle est la longueur d'un UUID ?

Un UUID fait 128 bits, soit 16 octets. Sa forme texte standard compte 36 caractères : 32 chiffres hexadécimaux et 4 tirets. Sans tirets, il en compte 32, et 38 avec des accolades.

Peut-on mettre des UUID dans des URL sans risque ?

On peut les afficher, mais ils ne remplacent pas un contrôle d'accès. Un v4 aléatoire est difficile à deviner, mais il peut fuiter via les journaux, l'historique du navigateur ou l'en-tête Referer, et les v1 et v7 révèlent leur date de création. Vérifiez toujours que l'utilisateur a le droit d'accéder à la ressource.

Essayez gratuitement : Générateur d'UUID Gratuit, sans création de compte.