Skip to content

Générateur & Décodeur UUID

Générateur UUID gratuit — créez des UUID v1, v4, v5, v7 instantanément. Décodez et validez tout UUID. Génération par lots jusqu'à 50. 100 % dans le navigateur.

Sans pistage Fonctionne dans le navigateur Gratuit
Tous les UUID sont générés localement dans votre navigateur. Rien n'est transmis ni stocké.

Qu'est-ce qu'un UUID ?

Un UUID (Universally Unique Identifier) est un identifiant de 128 bits standardisé par le RFC 9562 (anciennement RFC 4122). Les UUID s'écrivent sous forme de 32 chiffres hexadécimaux au format canonique 8-4-4-4-12, tel que `550e8400-e29b-41d4-a716-446655440000`. Ils sont conçus pour être globalement uniques sans nécessiter d'autorité centrale ni de coordination entre systèmes.

Il existe cinq versions d'UUID largement utilisées. La version 1 (v1) encode l'horodatage actuel et l'adresse MAC de la machine génératrice, rendant chaque UUID unique dans le temps et l'espace. Les versions 3 (v3) et 5 (v5) sont déterministes — elles hachent un espace de noms et un nom à l'aide de MD5 ou SHA-1 respectivement, produisant toujours le même UUID pour les mêmes entrées. La version 4 (v4) est la plus courante : elle remplit 122 bits avec des données aléatoires cryptographiquement sécurisées, offrant plus de 5,3 x 10^36 valeurs possibles. La version 7 (v7), introduite dans le RFC 9562, combine un horodatage Unix en millisecondes avec des données aléatoires, produisant des UUID à la fois uniques et naturellement triables par date de création.

Les UUID sont essentiels dans les systèmes distribués, les bases de données, les API et partout où des identifiants uniques sont nécessaires sans coordination centralisée. Ils éliminent le risque de collision d'identifiants entre systèmes indépendants, ce qui les rend idéaux pour les microservices, le sourcing d'événements et les architectures multi-locataires.

Cet outil génère toutes les versions d'UUID entièrement dans votre navigateur à l'aide de l'API Web Crypto. Aucun UUID n'est transmis à un serveur, garantissant une confidentialité totale. Vous pouvez également décoder et valider des UUID existants pour inspecter leur version, variante et données intégrées.

// Generate a UUID v4 using the Web Crypto API
const uuid = crypto.randomUUID();
console.log(uuid);
// → '550e8400-e29b-41d4-a716-446655440000'

// Manual v4 generation with crypto.getRandomValues()
function generateUUIDv4() {
  const bytes = new Uint8Array(16);
  crypto.getRandomValues(bytes);
  bytes[6] = (bytes[6] & 0x0f) | 0x40; // version 4
  bytes[8] = (bytes[8] & 0x3f) | 0x80; // variant 10
  const hex = Array.from(bytes, b => b.toString(16).padStart(2, '0')).join('');
  return `${hex.slice(0,8)}-${hex.slice(8,12)}-${hex.slice(12,16)}-${hex.slice(16,20)}-${hex.slice(20)}`;
}

Fonctionnalités clés

Support UUID v7 (RFC 9562)

Générez le dernier format UUID v7 avec horodatage Unix intégré pour des identifiants ordonnés dans le temps et optimisés pour les bases de données. L'un des rares outils en ligne supportant le standard RFC 9562.

Décodeur et validateur UUID

Analysez n'importe quel UUID pour révéler sa version, sa variante, son horodatage (v1/v7), sa séquence d'horloge et les informations de nœud. Validez instantanément si une chaîne est un UUID correctement formaté.

Support multi-versions

Générez des UUID en cinq versions — v1 (basé sur le temps), v3 (MD5), v4 (aléatoire), v5 (SHA-1) et v7 (aléatoire ordonné dans le temps) — tous conformes au RFC 9562.

Génération par lots

Générez jusqu'à 50 UUID uniques à la fois. Chaque UUID est généré indépendamment avec une aléatoire cryptographique complète ou un encodage correct spécifique à la version.

Formats de sortie multiples

Produisez des UUID en minuscules standard, MAJUSCULES, sans tirets ou au format accolades {GUID} — correspondant exactement au format requis par votre système ou framework.

Sécurité cryptographique

Utilise l'API Web Crypto (crypto.getRandomValues()) pour une véritable génération de nombres aléatoires — le même standard utilisé par les navigateurs modernes et les outils de sécurité.

100 % dans le navigateur

Tous les UUID sont générés localement dans votre navigateur. Rien n'est envoyé à un serveur — vos identifiants générés restent totalement privés.

Comparaison des versions UUID

Choisissez la bonne version UUID pour votre cas d'utilisation.

Version Base Triable Confidentialité Idéal pour
v1 Horodatage + adresse MAC Par date de création Expose MAC et horodatage Systèmes hérités nécessitant un ordonnancement temporel
v4 122 bits aléatoire cryptographique Non Totalement anonyme Usage général — version la plus utilisée
v5 Hachage SHA-1 (espace de noms + nom) Non Déterministe, reproductible Identifiants cohérents à partir d'entrées connues (URL, DNS)
v7 Horodatage Unix (ms) + aléatoire Par date de création Expose uniquement l'heure de création Bases de données modernes — triable, optimisé pour les index (RFC 9562)

UUID vs autres formats d'identifiants

ULID

26 caractères, Crockford Base32

Triable lexicographiquement comme UUID v7, mais utilise l'encodage Crockford Base32 (26 caractères vs 36). UUID v7 est désormais l'alternative standardisée par l'IETF avec un support d'outils plus large.

nanoid

21 caractères, alphabet compatible URL

Plus court et compatible URL, idéal quand la compacité est importante. Pas un standard formel — manque les types de base de données natifs et les bibliothèques multiplateformes que possède UUID.

CUID2

Longueur variable, alphanumérique

Conçu pour la mise à l'échelle horizontale avec résistance aux collisions. Moins largement adopté que UUID ; pas de support natif en base de données. Considérez UUID v7 pour des identifiants triés par temps standardisés.

Exemples de versions UUID

UUID v4 (Aléatoire)

550e8400-e29b-41d4-a716-446655440000

La version la plus couramment utilisée. 122 bits d'aléatoire cryptographique offrent plus de 5,3 x 10^36 valeurs possibles — adaptée à pratiquement tout cas d'usage nécessitant une unicité sans coordination.

UUID v7 (Ordonné dans le temps)

01906b5e-4a3e-7234-8f56-b8c12d4e5678

Combine un horodatage Unix de 48 bits en millisecondes avec des données aléatoires. Les UUID se trient chronologiquement, ce qui les rend idéaux pour les clés primaires de base de données où la localité d'index est importante. Recommandé pour les nouveaux projets plutôt que v1 et v4.

UUID v1 (Basé sur le temps)

6ba7b810-9dad-11d1-80b4-00c04fd430c8

Encode un horodatage de 60 bits et l'adresse MAC de 48 bits de la machine génératrice. Garantit l'unicité dans le temps et l'espace mais peut divulguer des informations d'identité matérielle. Remplacé par v6/v7 dans le RFC 9562.

UUID v5 (Basé sur le nom SHA-1)

886313e1-3b8a-5372-9b90-0c9aee199e5d

UUID déterministe généré en hachant l'espace de noms DNS avec le nom 'python.org' à l'aide de SHA-1. Le même espace de noms et le même nom produisent toujours le même UUID, ce qui rend v5 idéal pour les identifiants reproductibles.

Comment utiliser

  1. 1

    Sélectionnez la version UUID

    Choisissez parmi v1 (basé sur le temps), v3 (basé sur le nom MD5), v4 (aléatoire), v5 (basé sur le nom SHA-1) ou v7 (aléatoire ordonné dans le temps). Chaque version répond à un objectif différent — v4 est la plus courante pour un usage général.

  2. 2

    Configurez les options

    Pour v3 et v5, sélectionnez un espace de noms (DNS, URL, OID, X.500 ou personnalisé) et entrez un nom à hacher. Définissez la quantité de 1 à 50 et choisissez un format de sortie : minuscules standard, MAJUSCULES, sans tirets ou accolades {GUID}.

  3. 3

    Générez les UUID

    Cliquez sur le bouton Générer. Chaque UUID est créé à l'aide de l'API Web Crypto (crypto.getRandomValues()) pour une sécurité cryptographique. Les champs spécifiques à chaque version comme les horodatages (v1/v7) et les hachages (v3/v5) sont correctement encodés.

  4. 4

    Copiez et utilisez

    Cliquez sur le bouton Copier à côté d'un UUID pour le copier dans le presse-papiers, ou utilisez Tout copier pour récupérer tous les UUID générés en une fois. Passez à l'onglet Décoder pour analyser la version, la variante, l'horodatage et autres informations intégrées d'un UUID existant.

Cas d'utilisation courants

Clés primaires de base de données
Utilisez UUID v4 ou v7 comme clés primaires uniques sans coordination entre les nœuds de base de données. UUID v7 est particulièrement adapté car sa propriété d'ordonnancement temporel améliore les performances des index B-tree.
Systèmes distribués
Générez des identifiants uniques indépendamment à travers les microservices, les files de messages et les systèmes de sourcing d'événements. Les UUID éliminent le besoin d'un service centralisé de génération d'identifiants.
Développement d'API
Créez des identifiants de requête uniques, des identifiants de corrélation et des clés d'idempotence pour les API RESTful et GraphQL. Les UUID facilitent le traçage des requêtes à travers les frontières des services distribués.
Gestion des sessions et jetons
Générez des identifiants de session uniques et des jetons temporaires pour les flux d'authentification. Les UUID offrent une unicité suffisante pour éviter les collisions de sessions sur de larges bases d'utilisateurs.
Tests et développement
Générez rapidement des données de test, des identifiants fictifs et des identifiants de fixtures uniques pour les tests automatisés. La génération par lots facilite le remplissage des bases de données de développement et des suites de tests.

Détails techniques

Structure d'un UUID
Un UUID fait 128 bits (16 octets) représentés par 32 caractères hexadécimaux au format 8-4-4-4-12. Les bits 48-51 (le 13e chiffre hex) encodent le numéro de version. Les bits 64-65 encodent le champ de variante, qui identifie la disposition de l'UUID. Les bits restants contiennent la charge utile spécifique à la version : horodatage, données aléatoires ou résultat de hachage.
Bits de version
Les bits 48-51 (le quartet haut du 7e octet) encodent la version de l'UUID : 0001 = v1 (basé sur le temps), 0011 = v3 (basé sur le nom MD5), 0100 = v4 (aléatoire), 0101 = v5 (basé sur le nom SHA-1), 0110 = v6 (temps réordonné), 0111 = v7 (époque Unix). Ces quatre bits sont toujours définis explicitement lors de la génération.
Champ de variante
Les bits 64-65 (les deux bits les plus significatifs du 9e octet) définissent la variante. Le motif 10x indique les UUID RFC 4122/9562 (la grande majorité). Le motif 110 indique les GUID Microsoft avec un ordre d'octets mixte (mixed-endian). Le motif 0xx indique les UUID compatibles NCS (hérité). Le motif 111 est réservé pour un usage futur.
Standard RFC 9562
Le RFC 9562, publié en mai 2024, remplace le RFC 4122 comme spécification UUID définitive. Il introduit formellement les versions 6, 7 et 8 des UUID. La version 6 réordonne les champs de v1 pour la triabilité. La version 7 utilise un horodatage Unix de 48 bits en millisecondes plus des données aléatoires, ce qui en fait la version recommandée pour les nouveaux UUID basés sur le temps. La version 8 fournit un format pour les UUID personnalisés, spécifiques à l'implémentation. Le RFC 9562 déprécie également formellement v1 en faveur de v6/v7.

Bonnes pratiques

Choisissez la bonne version
Utilisez v4 pour les identifiants uniques à usage général lorsqu'aucun ordonnancement ni déterminisme n'est nécessaire. Utilisez v7 pour les clés primaires de base de données — sa propriété d'ordonnancement temporel offre des performances d'index significativement meilleures. Utilisez v5 lorsque vous avez besoin d'identifiants déterministes dérivés de noms (préférez v5 à v3 pour un hachage plus robuste).
Utilisez UUID v7 pour les clés primaires de base de données
La structure ordonnée dans le temps de UUID v7 maintient les insertions B-tree séquentielles, réduisant la fragmentation des index d'environ 90 % par rapport aux UUID v4 aléatoires. Cela se traduit par des écritures plus rapides, des index plus petits et une meilleure utilisation du cache. La plupart des bases de données modernes (PostgreSQL 17+, MySQL 8.0+) disposent d'un support natif UUID optimisé pour ce schéma.
N'utilisez jamais les UUID comme jetons de sécurité
Les UUID sont conçus pour l'unicité, pas pour le secret. UUID v1 divulgue l'horodatage de génération et l'adresse MAC. UUID v4 n'a que 122 bits d'entropie avec une structure prévisible. Pour les jetons de sécurité, les clés API ou les secrets de session, utilisez un CSPRNG dédié pour générer 128 ou 256 bits de données purement aléatoires sans la surcharge de la structure UUID.
Validez avant d'analyser
Validez toujours le format UUID avec une expression régulière avant de l'analyser ou de le stocker. Rejetez les entrées malformées aux frontières du système — points de terminaison d'API, soumissions de formulaires et entrées de base de données. Cela prévient les attaques par injection, la corruption de données et les erreurs difficiles à déboguer causées par des identifiants invalides se propageant dans votre système.

Questions fréquentes

Qu'est-ce qu'un UUID ?
Un UUID (Universally Unique Identifier) est un identifiant de 128 bits standardisé par le RFC 9562. Il s'écrit sous forme de 32 chiffres hexadécimaux affichés en cinq groupes séparés par des tirets, au format 8-4-4-4-12 — par exemple, 550e8400-e29b-41d4-a716-446655440000. Les UUID sont conçus pour être globalement uniques sans nécessiter d'autorité d'enregistrement centrale. Le terme GUID (Globally Unique Identifier) est le nom utilisé par Microsoft pour le même concept et emploie un format identique. Les UUID sont largement utilisés dans les bases de données, les systèmes distribués, les API et le développement logiciel partout où des identifiants uniques sont nécessaires. Avec plus de 5,3 x 10^36 UUID v4 possibles, la probabilité de générer un doublon est astronomiquement faible, ce qui les rend sûrs pour une génération indépendante entre systèmes non coordonnés.
Quelles sont les différences entre les versions d'UUID ?
UUID v1 encode un horodatage de 60 bits et l'adresse MAC de 48 bits de la machine, garantissant l'unicité dans le temps et l'espace mais pouvant divulguer l'identité matérielle. UUID v3 hache un espace de noms et un nom avec MD5 pour produire un UUID déterministe — les mêmes entrées donnent toujours le même résultat. UUID v4 remplit 122 de ses 128 bits avec des données aléatoires cryptographiquement sécurisées, ce qui en fait la version la plus utilisée pour les identifiants uniques à usage général. UUID v5 est identique à v3 mais utilise SHA-1 au lieu de MD5, offrant une meilleure résistance aux collisions de hachage. UUID v7, introduit dans le RFC 9562 (mai 2024), intègre un horodatage Unix de 48 bits en millisecondes suivi de bits aléatoires, produisant des UUID à la fois uniques et naturellement triables par date de création. Le choix de version dépend de vos besoins : v4 pour la simplicité, v5 pour le déterminisme et v7 pour les clés de base de données triables dans le temps.
Quand utiliser UUID v4 plutôt que v7 ?
UUID v4 est la version la plus populaire et un excellent choix par défaut. Il génère 122 bits d'aléatoire pur, ne nécessite aucune configuration et fonctionne partout. Utilisez v4 quand vous avez simplement besoin d'un identifiant unique et que l'ordre n'a pas d'importance. UUID v7 est le meilleur choix lorsque les UUID serviront de clés primaires de base de données ou devront être triés par date de création. Comme v7 intègre un horodatage en millisecondes dans les bits les plus significatifs, les UUID v7 se trient naturellement par ordre chronologique. Cette propriété améliore considérablement les performances des index B-tree — les insertions vont toujours à la fin de l'index plutôt qu'à des positions aléatoires, réduisant les divisions de pages et la fragmentation jusqu'à 90 %. Pour les nouveaux projets en 2026, la recommandation générale est d'utiliser v7 pour les clés de base de données et v4 pour tout le reste. Les deux versions sont également uniques et cryptographiquement aléatoires dans leurs portions aléatoires.
Quelle est la probabilité de collision d'UUID ?
UUID v4 possède 122 bits aléatoires, soit 2^122 (environ 5,3 x 10^36) valeurs possibles. Pour avoir une probabilité de 50 % d'au moins une collision, il faudrait générer environ 2,71 x 10^18 UUID — soit 2,71 trillions. Pour mettre cela en perspective, si vous génériez un milliard d'UUID par seconde, il faudrait environ 86 ans pour atteindre une probabilité de collision de 50 %. À des taux de génération plus réalistes, la probabilité est infinitésimale. Par exemple, générer 10 millions d'UUID produit une probabilité de collision d'environ 1 sur 10^22. En pratique, les pannes matérielles, les bugs logiciels et les erreurs humaines sont tous des milliards de fois plus susceptibles de causer des identifiants dupliqués que les collisions d'UUID v4. Le calcul repose sur la formule du paradoxe des anniversaires : p(n) est approximativement égal à n^2 / (2 * 2^122).
Quelle est la différence entre UUID et GUID ?
UUID (Universally Unique Identifier) et GUID (Globally Unique Identifier) désignent essentiellement la même chose. GUID est le terme inventé par Microsoft et utilisé principalement dans les environnements Windows, .NET, COM et SQL Server. UUID est le terme standard défini par le RFC 9562 (et son prédécesseur RFC 4122) et est utilisé dans la plupart des autres contextes, notamment Linux, Java, Python, PostgreSQL et le développement web. Les deux utilisent le même format de 128 bits affiché en 32 chiffres hexadécimaux au format 8-4-4-4-12. La seule différence mineure est que les outils Microsoft affichent parfois les GUID en majuscules avec des accolades, comme {550E8400-E29B-41D4-A716-446655440000}, tandis que les UUID sont conventionnellement affichés en minuscules sans accolades. Cet outil prend en charge les deux formats via le sélecteur de format de sortie — choisissez le format Accolades {GUID} pour la sortie style Microsoft.
UUID v4 est-il cryptographiquement sécurisé ?
Lorsqu'il est généré avec crypto.getRandomValues() ou un CSPRNG (générateur de nombres pseudo-aléatoires cryptographiquement sécurisé) équivalent, UUID v4 contient 122 bits de données aléatoires cryptographiquement sécurisées. Cet outil utilise l'API Web Crypto, qui puise l'entropie dans la source aléatoire sécurisée du système d'exploitation. Cependant, les UUID ne doivent pas être utilisés comme jetons de sécurité, mots de passe ou clés de chiffrement. Bien que 122 bits d'aléatoire rendent la prédiction irréalisable, les UUID ont une structure prévisible — le quartet de version (4) et les bits de variante sont fixes et publiquement connus. Pour les jetons de sécurité, utilisez des API spécialisées comme crypto.getRandomValues() avec 128 ou 256 bits d'entropie complets, ou des formats de jetons établis comme JWT. Utilisez les UUID pour l'identification, pas pour la sécurité.
Comment valider le format d'un UUID ?
Un UUID valide correspond au motif d'expression régulière : ^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$ (insensible à la casse). Ce motif impose le format hexadécimal 8-4-4-4-12, vérifie que le chiffre de version (position 15) est entre 1 et 7, et s'assure que le quartet de variante (position 20) commence par 8, 9, a ou b (indiquant la variante RFC 4122/9562). En JavaScript, vous pouvez valider avec : /^[0-9a-f]{8}-[0-9a-f]{4}-[1-7][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(uuid). La plupart des langages de programmation disposent également d'un analyseur UUID intégré — par exemple, uuid.UUID() en Python, UUID.fromString() en Java et uuid.Parse() en Go. Validez toujours les UUID aux frontières du système avant de les stocker ou de les traiter pour prévenir les attaques par injection et la corruption de données.
Les UUID sont-ils de bonnes clés primaires ? (Performance, sécurité et meilleure version)
Oui, les UUID sont sûrs et de plus en plus courants comme clés primaires de base de données, UUID v7 étant la version recommandée. Les avantages clés : (1) Les UUID peuvent être générés n'importe où — clients, serveurs ou fonctions edge — sans aller-retour vers la base de données, permettant des architectures distribuées et offline-first. (2) Les UUID empêchent les attaques par énumération car ils ne sont pas des entiers séquentiels. (3) Les UUID simplifient la fusion de données entre systèmes car les identifiants ne sont jamais en conflit. UUID v7 est la meilleure version pour les clés primaires car sa structure ordonnée dans le temps maintient les index B-tree séquentiels, réduisant les divisions de pages, l'amplification d'écriture et la fragmentation des index jusqu'à 90 % par rapport aux UUID v4 aléatoires. Les compromis : les UUID utilisent 16 octets contre 4-8 octets pour les entiers. Sous MySQL/InnoDB, les UUID v4 aléatoires peuvent causer une dégradation significative des performances — v7 garantit que les insertions s'ajoutent toujours à la fin de l'index, avec des performances comparables aux entiers auto-incrémentés. PostgreSQL stocke les UUID nativement en 16 octets avec le type uuid. Pour la plupart des applications modernes, les avantages l'emportent largement sur le coût de stockage supplémentaire.
Qu'est-ce qu'un espace de noms UUID (v3/v5) ?
Un espace de noms UUID est un UUID prédéfini ou personnalisé qui sert de portée pour générer des UUID v3 et v5 déterministes. Le RFC 4122 définit quatre espaces de noms standard : DNS (6ba7b810-9dad-11d1-80b4-00c04fd430c8), URL (6ba7b811-9dad-11d1-80b4-00c04fd430c8), OID (6ba7b812-9dad-11d1-80b4-00c04fd430c8) et X.500 DN (6ba7b814-9dad-11d1-80b4-00c04fd430c8). Lorsque vous combinez un UUID d'espace de noms avec une chaîne de nom, l'algorithme v3 ou v5 les hache ensemble pour produire un UUID déterministe — le même espace de noms plus le même nom produit toujours le même UUID. C'est utile lorsque vous avez besoin d'identifiants reproductibles dérivés de noms significatifs. Par exemple, le hachage de l'espace de noms DNS avec 'example.com' produit toujours le même UUID v5. Vous pouvez également utiliser n'importe quel UUID valide comme espace de noms personnalisé pour le schéma d'identifiants déterministes de votre application.
Qu'est-ce que la valeur nil d'un UUID ?
L'UUID nil (également appelé UUID zéro) est 00000000-0000-0000-0000-000000000000 — tous les 128 bits mis à zéro. Il est défini dans le RFC 9562 Section 5.9 comme un UUID spécial pouvant représenter l'absence de valeur, similaire à null ou None dans les langages de programmation. L'UUID nil est utile comme valeur sentinelle, comme valeur par défaut dans les systèmes de configuration, ou comme espace réservé dans les enregistrements de base de données lorsqu'un champ UUID ne doit pas être vide mais qu'aucune valeur réelle n'existe encore. Le RFC 9562 définit également l'UUID max : ffffffff-ffff-ffff-ffff-ffffffffffff (tous les bits à un), qui peut servir de marqueur de limite. Précautions importantes : n'utilisez jamais l'UUID nil comme identifiant réel — il n'est pas unique. Certaines bibliothèques UUID et bases de données peuvent rejeter ou traiter spécialement les UUID nil, assurez-vous donc que votre système les gère de manière cohérente. Documentez toujours si les UUID nil sont acceptés dans vos contrats d'API et schémas de base de données.
Qu'est-ce que UUID v7 et pourquoi l'utiliser ?
UUID v7 est la version UUID la plus récente définie dans le RFC 9562 (mai 2024). Il intègre un horodatage Unix de 48 bits en millisecondes dans les bits les plus significatifs, suivi de données aléatoires cryptographiques. Cette conception produit des UUID globalement uniques, triables chronologiquement et très efficaces comme clés primaires de base de données. Contrairement à UUID v1, qui contient également un horodatage, v7 utilise un format Unix epoch plus simple et n'expose pas votre adresse MAC. La structure ordonnée dans le temps réduit la fragmentation des index B-tree jusqu'à 90 % par rapport à UUID v4 aléatoire. Pour les nouveaux projets en 2026, UUID v7 est le choix recommandé pour tout scénario nécessitant un ordonnancement temporel.
Comment décoder un UUID ?
Décoder un UUID consiste à extraire les informations structurelles encodées dans ses 128 bits. Chaque UUID contient un champ de version (bits 48-51) identifiant comment il a été généré, et un champ de variante (bits 64-65) identifiant le standard UUID auquel il se conforme. Les différentes versions intègrent des données différentes : UUID v1 et v6 contiennent un horodatage de 60 bits et un nœud de 48 bits (adresse MAC) ; UUID v7 contient un horodatage Unix de 48 bits en millisecondes ; UUID v3 et v5 contiennent un hachage tronqué d'un espace de noms et d'un nom. Pour décoder un UUID, collez-le dans l'onglet Décoder de cet outil. Il affichera instantanément la version, la variante, l'horodatage (pour les versions basées sur le temps) et le statut de validité.
UUID vs ULID vs nanoid — lequel choisir ?
UUID, ULID et nanoid servent le même objectif fondamental — générer des identifiants uniques — mais diffèrent en format, triabilité et standardisation. UUID est le standard le plus largement adopté (RFC 9562), supporté nativement par pratiquement toutes les bases de données, langages et frameworks. UUID v7 fournit un tri basé sur le temps dans le format standard de 128 bits et 36 caractères. ULID est antérieur à UUID v7 et utilise l'encodage Crockford Base32 pour produire une chaîne triable de 26 caractères. Maintenant que UUID v7 existe comme standard IETF, le principal avantage de ULID — la triabilité — est disponible dans le format UUID universel. nanoid génère des identifiants plus courts (21 caractères par défaut) avec un alphabet compatible URL. Pour la plupart des applications, UUID v4 (usage général) ou UUID v7 (clés de base de données) est le choix recommandé.

Outils connexes

Voir tous les outils →

Générateur de Hash MD5 en Ligne et Vérificateur de Checksum

Outils de sécurité

Générez des hashes MD5, SHA-256, SHA-1 et SHA-512 gratuitement — 100% dans votre navigateur, sans inscription. Hachez texte ou fichiers, vérifiez les checksums et comparez les hashes en un clic. Vos données restent privées.

Générateur de Mot de Passe Aléatoire

Outils de sécurité

Générez des mots de passe forts et sécurisés — gratuit, 100% dans votre navigateur. Personnalisez longueur et caractères, générez jusqu'à 50. Aucune donnée stockée.

Convertisseur de Base — Binaire, Hex, Décimal & Octal

Outils de conversion

Convertissez des nombres entre binaire, hexadécimal, décimal, octal et toute base personnalisée (2-36) instantanément. Gratuit, privé, sans inscription — tout se passe dans votre navigateur.

Décodeur et Encodeur Base64

Encodage et formatage

Décodez et encodez en Base64 en ligne gratuitement. Conversion en temps réel, support UTF-8 et émojis. 100 % privé — dans votre navigateur. Sans inscription.

Compresseur d'Images en Ligne Gratuit

Outils de conversion

Compressez vos images JPEG, PNG & WebP gratuitement dans le navigateur — aucun envoi serveur. Lots de 20 images, qualité réglable, comparaison avant/après. 100% privé, sans inscription.

Formateur et Validateur JSON

Encodage et formatage

Formatez, validez et embellissez vos JSON dans le navigateur. Outil gratuit avec validation syntaxique, detection d'erreurs, minification et copie. 100 % prive.