Générateur UUID/GUID
Générez instantanément des UUIDs v4 (aléatoires), v1 ou v7 (horodatés), jusqu'à 100 à la fois. Gratuit, rapide, sans installation, directement dans votre navigateur. Parfait pour développeurs.
Traitement 100 % local — rien ne quitte votre navigateur.En savoir plus
Générateur UUID (v1, v4, v7) : Créez des identifiants uniques instantanément
Générez des UUIDs (Universally Unique Identifiers) version 4, 1 ou 7, jusqu'à 100 à la fois, directement dans votre navigateur. Pour la version 4 (par défaut), cet outil gratuit utilise l'API cryptographique native crypto.randomUUID() : 122 bits aléatoires par identifiant, pour une unicité quasi certaine. Les versions 1 et 7 combinent l'heure de génération et des bits aléatoires tirés de crypto.getRandomValues().
Que vous soyez développeur backend cherchant des clés primaires pour vos bases de données, développeur frontend gérant des identifiants de session, ou architecte système concevant des APIs distribuées, ce générateur UUID répond à tous vos besoins d'identification unique sans coordination centrale.
Comment utiliser
- Choisissez la version (v4 aléatoire par défaut, v1 ou v7 horodatées) et le nombre d'UUIDs (1 à 100)
- Cliquez sur le bouton "Générer UUID" : les UUIDs s'affichent instantanément au format standard (8-4-4-4-12)
- Utilisez le bouton "Copier" pour copier un UUID, ou "Tout copier" pour la liste entière (un UUID par ligne)
- Cliquez à nouveau sur "Générer UUID" pour obtenir de nouveaux identifiants
- Les parties aléatoires proviennent du générateur cryptographique de votre navigateur
💡 Pourquoi ce générateur UUID existe-t-il ?
Dans le développement moderne d'applications distribuées, générer des identifiants uniques de manière fiable est un défi constant. Les solutions traditionnelles comme les auto-incréments de bases de données créent des goulots d'étranglement et des problèmes de synchronisation dans les architectures distribuées.
Les UUIDs résolvent ce problème en permettant à n'importe quel système de générer des identifiants uniques de manière indépendante, avec un risque de collision négligeable. Ce générateur vous évite d'installer des bibliothèques, d'écrire du code ou de dépendre de services tiers.
🎯 Cas d'usage typique :
Vous développez une API REST et devez créer des identifiants pour de nouvelles ressources. Au lieu d'attendre l'insertion en base de données pour obtenir un ID auto-incrémenté, vous générez un UUID côté client, permettant un traitement asynchrone et une meilleure expérience utilisateur.
🔧 Cas d'utilisation concrets
🗄️ Bases de données distribuées
Utilisez les UUIDs comme clés primaires dans PostgreSQL, MongoDB ou DynamoDB pour éviter les conflits lors des réplications multi-maîtres.
CREATE TABLE users (id UUID PRIMARY KEY DEFAULT gen_random_uuid(), ...);
🌐 APIs RESTful
Créez des identifiants de ressources non séquentiels pour vos endpoints d'API : avec des UUIDs v4, impossible de parcourir vos ressources en incrémentant un ID (les contrôles d'accès restent indispensables).
POST /api/orders/a7b3c8d9-1234-4f5e-8abc-123456789def
🔐 Sessions et traçage
Identifiez une session ou une requête (logs, analytics). Pas pour un jeton d'authentification : la RFC 9562 interdit d'utiliser un UUID comme secret donnant accès à une ressource.
sessionStorage.setItem('session_id', crypto.randomUUID());
📁 Noms de fichiers uniques
Évitez les collisions de noms lors de l'upload de fichiers sur S3, Azure Blob ou tout système de stockage cloud.
const filename = `${crypto.randomUUID()}.pdf`;
🎫 Systèmes de tickets
Créez des numéros de tickets, commandes ou références clients uniques et non séquentiels (v4), qui ne révèlent pas votre volume d'activité.
Ticket #f47ac10b-58cc-4372-a567-0e02b2c3d479
📊 Systèmes de cache distribués
Générez des clés de cache uniques pour Redis, Memcached ou tout système de mise en cache multi-instances.
redis.set(`cache:${uuid}`, data, 'EX', 3600);
✨ Pourquoi utiliser ce générateur plutôt qu'un autre ?
🚀 Instantané et local
Génération en moins de 1ms directement dans votre navigateur. Pas d'appel serveur, pas de latence réseau.
🔒 Cryptographiquement sécurisé
Les UUIDs v4 viennent de crypto.randomUUID(), l'API native des navigateurs (122 bits aléatoires, format conforme à la RFC 9562). Les v1 et v7 tirent leurs bits aléatoires de crypto.getRandomValues().
🕵️ 100% privé
Aucune donnée transmise à un serveur. Vos UUIDs ne quittent jamais votre machine. Parfait pour les données sensibles.
♻️ Illimité et gratuit
Générez de 1 à 100 UUIDs par clic, autant de fois que nécessaire, sans inscription, sans publicité. Toujours gratuit.
📱 Multi-plateforme
Fonctionne sur tous les navigateurs modernes : Chrome, Firefox, Safari, Edge. Desktop et mobile.
📋 Copie en un clic
Interface intuitive : un bouton de copie par UUID et « Tout copier » pour une série. Gagnez du temps dans votre workflow de développement.
❓ Questions fréquentes (FAQ)
Qu'est-ce qu'un UUID et comment fonctionne-t-il ?
Un UUID (Universally Unique Identifier) est un identifiant de 128 bits (16 octets) représenté sous forme de 32 caractères hexadécimaux séparés par des tirets : xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx, où M indique la version (1, 4 ou 7 avec cet outil) et N la variante (8, 9, a ou b).
Les UUIDs version 4 (générés par défaut par cet outil) sont créés de manière aléatoire (seuls 6 bits sont fixes) en utilisant un générateur de nombres pseudo-aléatoires cryptographiquement sécurisé. Les bits 4 à 7 du 7ème octet indiquent la version (4), et les bits 6 et 7 du 9ème octet indiquent la variante définie par la RFC 9562, qui a remplacé la RFC 4122 en mai 2024. Les versions 1 et 7 commencent par l'heure de génération (lisible par quiconque), suivie de bits aléatoires.
Avec 122 bits aléatoires, la probabilité que deux UUIDs v4 donnés soient identiques est de 1 sur 5,3×10³⁶, et reste pratiquement nulle même en générant des milliards d'UUIDs.
Quelle est la différence entre UUID et GUID ?
UUID et GUID sont la même chose, simplement des termes différents utilisés par différents écosystèmes :
- UUID (Universally Unique Identifier) : terme standard défini par la RFC 9562 (qui a remplacé la RFC 4122 en mai 2024), utilisé dans le monde Unix/Linux et les standards web
- GUID (Globally Unique Identifier) : terme utilisé par Microsoft dans l'écosystème Windows et .NET
Les deux désignent le même format de 128 bits. Notre générateur produit des identifiants compatibles avec les deux terminologies.
Puis-je utiliser les UUIDs générés en production ?
Oui, absolument ! Pour la v4, cet outil utilise crypto.randomUUID(), l'API native des navigateurs modernes, qui produit des UUID v4 conformes à la RFC 9562 (même format que dans l'ancienne RFC 4122). C'est la même méthode utilisée par les bibliothèques professionnelles comme uuid (npm) en mode navigateur.
Les UUIDs générés sont :
- ✅ Conformes à la RFC 9562 (versions 1, 4 et 7)
- ✅ Générés avec des bits aléatoires issus du CSPRNG du navigateur
- ✅ Compatibles avec toutes les bases de données modernes (PostgreSQL, MySQL, MongoDB, etc.)
- ✅ Utilisables comme clés primaires ou identifiants de ressources, mais pas comme jetons de session ou d'authentification (la RFC 9562 interdit d'en faire des secrets donnant accès)
Quel est le risque de collision (deux UUIDs identiques) ?
Le risque de collision entre deux UUIDs v4 est astronomiquement faible. Avec 122 bits d'entropie (après exclusion des bits de version et variante), il existe environ 5,3×10³⁶ combinaisons possibles.
Pour mettre cela en perspective :
- En générant 1 milliard d'UUIDs par seconde, il faudrait environ 86 ans pour avoir 50% de chance d'obtenir une collision
- Même après 1 000 milliards (10¹²) d'UUIDs v4, la probabilité d'une seule collision n'est que d'environ 1 sur 10 000 milliards
- La RFC 9562 rappelle toutefois qu'un UUID n'est pas un secret : il ne doit jamais servir de jeton d'accès
En pratique, le risque de collision est négligeable pour toute application réaliste.
Pourquoi choisir UUID v4 plutôt que v1, v5 ou v7 ?
Chaque version d'UUID a ses avantages :
- UUID v1 : Basé sur timestamp + identifiant de nœud (historiquement l'adresse MAC). ⚠️ Révèle l'heure de génération ; cet outil utilise un nœud aléatoire, donc aucune adresse MAC n'est exposée
- UUID v4 : Entièrement aléatoire. ✅ Aucune information révélée, maximum de sécurité et confidentialité
- UUID v5 : Basé sur hash (SHA-1) d'un namespace + nom. Utile pour générer des UUIDs déterministes (non proposé par cet outil)
- UUID v7 : Standardisé par la RFC 9562 (2024), avec timestamp en millisecondes + random. Triable par date de création, meilleur pour les index de bases de données (mais révèle l'heure de génération)
UUID v4 est recommandé quand vous voulez des identifiants impossibles à prédire, sans révéler d'information sur le système ou le moment de génération. C'est le choix par défaut pour la plupart des applications. Pour des clés primaires triables par date, préférez v7.
Les UUIDs sont-ils adaptés comme clés primaires en base de données ?
Oui, mais avec quelques considérations :
✅ Avantages :
- Génération décentralisée (pas besoin de coordonner avec la DB)
- Fusion de bases de données facilitée (pas de conflits d'IDs)
- Sécurité accrue (impossible de deviner le prochain ID)
- Compatibilité avec les architectures distribuées et microservices
⚠️ Inconvénients :
- Taille : 16 octets vs 4-8 pour un INT/BIGINT (impact sur les index)
- Performance d'insertion : moins bonne pour les index B-tree avec des v4 (ordre aléatoire)
- Lisibilité réduite pour le debugging
Solution : utilisez des UUIDs v7, triables par date (générés par cet outil, ou par uuidv7() depuis PostgreSQL 18), ou des UUIDs comme identifiants externes + auto-increment en interne.
Cet outil fonctionne-t-il hors ligne ?
Oui ! Une fois la page chargée, l'outil fonctionne entièrement hors ligne. Le JavaScript s'exécute localement dans votre navigateur et n'a besoin d'aucune connexion internet pour générer des UUIDs.
Vous pouvez même ajouter cette page à vos favoris ou l'ouvrir depuis le cache de votre navigateur. Parfait pour travailler en déplacement ou dans des environnements sans internet.
Comment intégrer la génération d'UUIDs dans mon code ?
JavaScript (navigateur moderne) :
const uuid = crypto.randomUUID(); // Natif, aucune dépendance
Node.js (v14.17+) :
const { randomUUID } = require('crypto');
const uuid = randomUUID();
Python :
import uuid
my_uuid = str(uuid.uuid4())
PostgreSQL :
SELECT gen_random_uuid(); -- natif depuis PostgreSQL 13 (pgcrypto avant)
SELECT uuidv7(); -- PostgreSQL 18+
Java :
String uuid = UUID.randomUUID().toString();
📚 Bonnes pratiques d'utilisation des UUIDs
Utilisez des UUIDs pour les identifiants exposés publiquement
Les URLs comme /users/123 permettent l'énumération. Préférez /users/a7b3c8d9-...
Stockez les UUIDs en format binaire (16 octets) en base de données
PostgreSQL : UUID, MySQL : BINARY(16). Convertissez depuis/vers string côté application.
Utilisez des index sur les colonnes UUID pour les performances
CREATE INDEX idx_orders_user_id ON orders(user_id); - Essentiel pour les jointures et recherches sur les clés étrangères (la clé primaire est déjà indexée automatiquement).
Ne comptez jamais sur l'ordre des UUIDs v4
Les UUIDs v4 sont aléatoires. Pour un tri chronologique, ajoutez une colonne created_at ou utilisez des UUIDs v7 (triables à la milliseconde près).
Validez toujours les UUIDs côté serveur
Utilisez une regex (versions 1, 4 et 7 ; ajoutez le flag i pour accepter les majuscules) : ^[0-9a-f]{8}-[0-9a-f]{4}-[147][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$
📖 Ressources et documentation
📄 RFC 9562 - Spécification UUID
Document officiel (mai 2024, remplace la RFC 4122) définissant le format et les versions des UUIDs, dont la v7.
Lire la RFC →🌐 MDN - crypto.randomUUID()
Documentation de l'API Web Crypto utilisée par cet outil.
Consulter MDN →🐘 PostgreSQL - Type UUID
Guide d'utilisation des UUIDs dans PostgreSQL avec exemples.
Documentation PostgreSQL →