Générateur d'UUID
Générateur en ligne gratuit d'UUID et d'identifiants uniques. Générez des UUID cryptographiquement sécurisés (v4, v1, v7), des ULID, NanoID, CUID2, Short ID et des identifiants au format personnalisé, en masse jusqu'à 1000 unités. Exportez en texte brut, JSON, CSV, SQL, XML, TypeScript ou Python. Comprend un analyseur/validateur d'UUID avec extraction d'horodatage et découpage des segments par couleur, un testeur de collisions, ainsi qu'un créateur de modèles personnalisés avec persistance localStorage.
—
How to Use
Choisissez parmi 8 formats d'identifiants : UUID v4 (aléatoire), v1 (horodatage), v7 (triable), ULID, NanoID, CUID2, Short ID, ou créez un modèle personnalisé. Le panneau Quick UUID affiche un UUID v4 en direct pour une copie instantanée.
Saisissez un nombre entre 1 et 1000, ou choisissez un préréglage. Sélectionnez votre format de sortie : texte brut, tableau JSON, objets JSON, CSV, SQL INSERT, XML, TypeScript ou Python.
Cliquez sur Generate pour produire instantanément tous les identifiants. En mode texte brut, chaque identifiant peut être cliqué individuellement pour être copié. Utilisez Copy All pour tout récupérer en une seule fois, ou Download pour l'enregistrer sous forme de fichier.
Passez à l'onglet UUID Parser pour valider et examiner n'importe quel UUID : consultez sa version, sa variante, son horodatage intégré et 7 formats alternatifs. Utilisez Compare Types pour choisir le meilleur format d'identifiant pour votre projet.
Que sont les UUID et pourquoi sont-ils importants ?
Un UUID (Universally Unique Identifier), aussi appelé GUID (Globally Unique Identifier), est un identifiant de 128 bits normalisé par la RFC 4122. Sa garantie fondamentale est qu'un UUID généré indépendamment sur n'importe quelle machine n'entrera jamais en collision avec un autre UUID, sans aucune coordination entre systèmes. C'est ce qui rend les UUID indispensables pour les bases de données distribuées, les microservices, l'event sourcing, et tout contexte où un identifiant doit exister avant même l'insertion en base ou la coordination avec un serveur central.
Les versions d'UUID expliquées
- UUID v4 (aléatoire) — 122 bits d'aléatoire cryptographique. Aucun composant temporel. C'est la version la plus utilisée car elle ne révèle rien sur le moment ou le lieu de création. À privilégier lorsque l'unicité et la confidentialité comptent plus que la possibilité de trier.
- UUID v1 (horodatage + MAC) — Encode un horodatage grégorien de 60 bits (intervalles de 100 nanosecondes depuis le 15 octobre 1582) ainsi qu'un identifiant de nœud. Cette implémentation utilise un nœud aléatoire (bit multicast activé) afin de protéger la confidentialité. Triable chronologiquement au sein d'un même nœud.
- UUID v7 (époque Unix, RFC 9562) — Horodatage Unix de 48 bits en millisecondes sur les 6 premiers octets, suivi de 74 bits d'aléatoire. Naturellement trié par les index B-tree des bases de données. C'est le remplaçant recommandé de la v1 pour les nouvelles applications.
Formats d'identifiants alternatifs
- ULID (Universally Unique Lexicographically Sortable Identifier) — Horodatage de 10 caractères en Crockford Base32 (précision de 48 ms) + composant aléatoire de 16 caractères = 26 caractères au total. Triable lexicographiquement, insensible à la casse, et 30 % plus court qu'un UUID avec tirets.
- NanoID — Compatible URL, compact, de longueur configurable. Utilise l'échantillonnage par rejet pour éliminer le biais de modulo. Avec ses 21 caractères par défaut et un alphabet alphanumérique, il atteint environ 126 bits de résistance aux collisions.
- CUID2 — Résistant aux collisions et aux empreintes (fingerprinting). Commence toujours par une lettre, en minuscules uniquement, adapté aux ID HTML et aux noms de classes CSS. Un bon choix par défaut pour les applications JavaScript.
- Short ID — Identifiants lisibles par un humain, de longueur configurable, construits à partir de plusieurs jeux de caractères. Utile pour les numéros de commande, les codes de parrainage et les références destinées aux utilisateurs.
- Modèle personnalisé — Combinez n'importe lequel des générateurs ci-dessus avec du texte statique, des horodatages et des numéros de séquence grâce à une syntaxe simple à base de
{token}.
Formats de sortie
Les identifiants générés peuvent être exportés dans 8 formats prêts à être collés directement dans votre code : texte brut (un par ligne, copie en un clic), tableau JSON, tableau d'objets JSON (avec clé configurable), CSV (avec en-tête), instruction SQL INSERT (table et colonne configurables), XML, tableau const TypeScript, et liste Python.
Analyseur et validateur d'UUID
L'onglet Analyseur accepte n'importe quelle chaîne UUID — avec ou sans tirets, au format URN (urn:uuid:…), ou entourée d'accolades. Il extrait la version et la variante, décode l'horodatage intégré dans les UUID v1 et v7, affiche une décomposition des segments en couleur, et propose 7 représentations alternatives, dont le Base64 et l'encodage en entier.
Testeur de collisions
Le test de collision génère jusqu'à 1 million d'UUID et vérifie chacun d'eux par rapport à un Set afin de détecter les doublons. Le test s'exécute par blocs non bloquants de 5 000 ID afin que le navigateur reste réactif. Une fois terminé, il affiche la probabilité de collision théorique ainsi que le résultat empirique.
Aléatoire cryptographique
Tous les générateurs de cet outil utilisent crypto.getRandomValues(), le générateur de nombres pseudo-aléatoires cryptographiquement sûr (CSPRNG) du navigateur. Math.random() n'est jamais utilisé. NanoID utilise l'échantillonnage par rejet pour éliminer le biais de modulo. Chaque identifiant est donc aussi aléatoire que le permet la réserve d'entropie de votre navigateur.
Confidentialité
Toute la génération se fait localement dans votre navigateur. Aucun identifiant, modèle ou format personnalisé n'est envoyé à un serveur. Les modèles enregistrés sont stockés uniquement dans le localStorage de votre navigateur et ne quittent jamais votre appareil.
Un UUID (Universally Unique Identifier) est un nombre de 128 bits qui peut être généré indépendamment sur n'importe quelle machine, sans aucune coordination. L'UUID v4 dispose de 122 bits d'aléatoire, ce qui signifie que la probabilité que deux UUID générés aléatoirement entrent en collision est d'environ 1 sur 5,3 × 10³⁶ — autant dire impossible en pratique. Le Collision Test vous permet de le vérifier empiriquement en générant jusqu'à 1 million d'UUID et en constatant zéro doublon.
L'UUID v4 est purement aléatoire — 122 bits d'aléatoire cryptographique, sans aucun horodatage. L'UUID v7 intègre un horodatage Unix de 48 bits en millisecondes dans les 6 premiers octets, ce qui fait que les UUID générés plus tard se trient après ceux générés plus tôt. C'est important pour les performances des bases de données : avec UUID v4 comme clé primaire, les lignes s'insèrent à des positions aléatoires dans l'index B-tree, provoquant des éclatements de page et de la fragmentation. UUID v7 s'insère à la fin de l'index, comme un entier auto-incrémenté, préservant ainsi la localité.
UUID (Universally Unique Identifier) et GUID (Globally Unique Identifier) désignent le même identifiant de 128 bits. « GUID » est le terme employé par Microsoft, utilisé dans .NET, SQL Server et COM. « UUID » est le terme issu de la norme de l'IETF (RFC 4122). Les deux sont interchangeables et ont exactement le même format.
Un ULID compte 26 caractères contre 36 pour un UUID avec tirets, soit 28 % plus court. Il est triable lexicographiquement (les ID plus récents se trient après les plus anciens), insensible à la casse, et utilise le Base32 de Crockford qui élimine les caractères ambigus (pas de O, I, L). Les ULID sont parfaits pour les systèmes de logs distribués, les flux d'événements, ou partout où vous avez besoin d'un identifiant plus court, triable, et également sûr pour les URL et les noms de fichiers.
Oui, avec quelques précautions. UUID v4 provoque une fragmentation des index dans les bases de données B-tree comme PostgreSQL, MySQL et SQL Server, car les ID aléatoires s'insèrent à des positions aléatoires. Pour les clés primaires, privilégiez plutôt UUID v7 ou ULID : tous deux intègrent un horodatage, ce qui garantit que les nouvelles lignes s'insèrent toujours à la fin de l'index, à l'image du comportement d'un auto-incrément. Si vous devez absolument utiliser v4, stockez-le en type binary(16) plutôt qu'en varchar(36) pour des performances d'index bien meilleures.
Pour un UUID v1, l'analyseur extrait l'horodatage grégorien de 60 bits (intervalles de 100 nanosecondes depuis le 15 octobre 1582) et le convertit en une date et heure UTC lisibles. Pour un UUID v7, il extrait l'horodatage Unix de 48 bits en millisecondes. Il identifie également l'octet de variante selon la RFC 4122, affiche une décomposition des segments en couleur (time-low, time-mid, version, variant, node/random), et fournit 7 représentations alternatives : standard, sans tirets, majuscules, URN, entre accolades, Base64 et entier.
Oui. Tout l'aléatoire provient de crypto.getRandomValues(), le générateur de nombres aléatoires cryptographiquement sûr du navigateur. Rien n'est généré côté serveur et rien n'est transmis sur le réseau : toute la génération a lieu dans le moteur JavaScript de votre navigateur. Les identifiants générés sont adaptés à un usage comme clés primaires de base de données, jetons de session, identifiants de corrélation, et autres usages en production. Pour les jetons sensibles en matière de sécurité (clés d'API, cookies de session), veillez également à utiliser HTTPS et des politiques de rotation appropriées.
Le modèle personnalisé utilise des jetons entre accolades que vous pouvez combiner avec du texte statique : {v4} insère un UUID v4, {v7} insère un UUID v7, {ulid} insère un ULID, {nano} insère un NanoID de 21 caractères, {random:N} insère N caractères alphanumériques aléatoires, {ts} insère l'horodatage Unix actuel en millisecondes, {date} insère la date du jour au format YYYYMMDD, et {seq} insère un compteur séquentiel. Par exemple, ORDER-{date}-{random:6} produit des identifiants tels que ORDER-20260318-k8Mn2X.