# UUID generator

> Genereer gratis en snel UUID's online. Ondersteunt alle UUID-versies (v1, v3-v7) en kan duizenden ID's tegelijk aanmaken, direct in je browser.

URL: https://acrafto.com/nl/uuid-generator/

Tools are interactive browser apps; there is no public API, no endpoints to call and no server-side processing. To use a tool, open its HTML page in a browser.

## Wat is UUID?

UUID (Universally Unique Identifier) is een 128-bits identificatie die in computersystemen wordt gebruikt voor het uniek identificeren van informatie. UUID is gestandaardiseerd volgens RFC 4122 en garandeert, dankzij zijn enorme entropie, een praktisch nul kans op botsingen – wat betekent dat twee onafhankelijk gegenereerde UUID’s vrijwel zeker uniek zullen zijn.

UUID heeft een standaardformaat: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, waarbij elke `x` een hexadecimaal cijfer is (0-9, a-f), `M` de UUID-versie aangeeft en `N` de variant.

## UUID Versies

### UUID v1 (Tijdstempel + MAC-adres)

UUID v1 is gebaseerd op de huidige tijdstempel en een willekeurige waarde (in de browser in plaats van het MAC-adres). Het gebruikt 100-nanoseconde-intervallen vanaf 15 oktober 1582 (Gregoriaanse kalender).

**Gebruik:**

- Situaties waarin u chronologische sortering van UUID’s nodig heeft
- Debugging en logging (UUID bevat informatie over de aanmaaktijd)
- Gedistribueerde systemen met tijdssynchronisatie

**Voorbeeld:** `6ba7b810-9dad-11d1-80b4-00c04fd430c8`

**Voordelen:**

- UUID’s kunnen chronologisch worden gesorteerd op aanmaaktijd
- Handig voor auditing en debugging
- Bevat tijdstempel informatie

**Nadelen:**

- Potentieel beveiligingsrisico – bevat tijdstempel
- Bevat geen echt MAC-adres in de browser (vervangen door een willekeurige waarde)
- Slechte DB-locatie (tijdstempel bevindt zich in de low-order bits)

### UUID v3 (MD5-hash)

UUID v3 wordt gegenereerd met behulp van een MD5-hash van de UUID-naamruimte en de naam. Deterministisch – dezelfde naamruimte + naam genereert altijd dezelfde UUID.

**Gebruik:**

- Conversie van URL’s, DNS-namen of andere identificaties naar UUID
- Situaties waarin u reproduceerbare UUID’s nodig heeft
- Mapping tussen verschillende identificatiesystemen

**Voorbeeld:** `a3bb189e-8bf9-3888-9912-ace4e6543002`

**Voordelen:**

- Deterministisch (zelfde invoer = zelfde uitvoer)
- Ideaal voor de conversie van bekende identificaties
- Geen botsingen voor verschillende invoeren

**Nadelen:**

- MD5 is een verouderd algoritme (geef de voorkeur aan v5)
- Vereist naamruimte en naam
- Kan de oorspronkelijke invoer niet herstellen

### UUID v4 (Willekeurig) - AANBEVOLEN

De meest gebruikte UUID-versie. UUID v4 wordt puur willekeurig gegenereerd met behulp van een cryptografisch veilige generator voor willekeurige getallen (`crypto.getRandomValues()`).

**Gebruik:**

- Primaire sleutels voor databases
- Sessie-identificaties (session ID’s)
- Unieke bestandsnamen
- API-tokens
- Algemene doeleinden, waar u een gegarandeerd unieke ID nodig heeft

**Voorbeeld:** `f47ac10b-58cc-4372-a567-0e02b2c3d479`

**Voordelen:**

- Maximale entropie en veiligheid
- Geen afhankelijkheid van tijd of systeemparameters
- Eenvoudigste implementatie

**Kans op botsing:** Bij het genereren van 1 miljard UUID’s per seconde gedurende 100 jaar is de kans op een botsing ongeveer 0,00000006%.

### UUID v5 (SHA-1-hash)

UUID v5 is hetzelfde als v3, maar gebruikt SHA-1 in plaats van MD5. Een moderner en veiliger alternatief voor v3.

**Gebruik:**

- Hetzelfde als v3, maar met betere beveiliging
- Te verkiezen boven v3 voor nieuwe projecten
- Genereren van UUID’s uit URL’s, DNS-namen, OID’s, X.500 DN

**Voorbeeld:** `886313e1-3b8a-5372-9b90-0c9aee199e5d`

**Voordelen:**

- Deterministisch
- SHA-1 is robuuster dan MD5
- Geschikt voor mapping tussen systemen

**Nadelen:**

- SHA-1 wordt ook als verouderd beschouwd (maar nog steeds veiliger dan MD5)
- Vereist naamruimte en naam

### UUID v6 (Gesorteerde tijdstempel)

UUID v6 is een verbeterde versie van v1 met opnieuw gerangschikte tijdsbits voor betere DB-indexering. Ontworpen om problemen met locatie in databases op te lossen.

**Gebruik:**

- Primaire sleutels voor databases met tijdssortering
- Systemen die chronologische sortering en DB-prestaties vereisen
- Moderner alternatief voor v1

**Voorbeeld:** `1ec9414c-232a-6b00-b3c8-9e6bdeced846`

**Voordelen:**

- Betere DB-locatie dan v1 (tijdstempel in high-order bits)
- Chronologische sortering
- Compatibel met de UUID-standaard

**Nadelen:**

- Minder gebruikt dan v1/v4
- Bevat nog steeds tijdsinformatie (beveiligingsrisico)

### UUID v7 (Unix tijdstempel)

UUID v7 gebruikt de Unix tijdstempel (milliseconden sinds 1970) + willekeurige bits. De nieuwste UUID-versie met de beste DB-locatie.

**Gebruik:**

- Moderne primaire sleutels voor databases
- Systemen die prestaties + tijdssortering vereisen
- Vervanging voor v1/v6 in nieuwe projecten

**Voorbeeld:** `017f22e2-79b0-7cc3-98c4-dc0c0c07398f`

**Voordelen:**

- Beste DB-locatie van alle versies
- Unix tijdstempel is standaard
- Combineert de voordelen van willekeurigheid en tijdssortering

**Nadelen:**

- Relatief nieuwe specificatie (RFC 4122bis)
- Minder ondersteund in oudere systemen

## Welke UUID-versie moet u gebruiken?

### Beslisgids

**Heeft u maximale veiligheid en willekeurigheid nodig?** → Gebruik **UUID v4** (meest gangbare keuze)

**Heeft u tijdssortering en DB-prestaties nodig?** → Gebruik **UUID v7** (modern) of **UUID v6** (standaard)

**Heeft u reproduceerbare UUID’s nodig uit bestaande identificaties?** → Gebruik **UUID v5** (SHA-1) of **UUID v3** (MD5, verouderd)

**Heeft u een tijdstempel en audittrail nodig?** → Gebruik **UUID v1** (verouderd, slechtere DB-prestaties)

### Databases

**Voor nieuwe projecten:** UUID v7 of v4

- **v7** is ideaal voor tijdssortering + prestaties
- **v4** voor maximale willekeurigheid zonder tijdsinformatie

**Voor oudere systemen:** UUID v1 of v6

- **v6** heeft een betere DB-locatie dan v1
- **v1** wordt breed ondersteund

**Voordelen van UUID als primaire sleutel:**

- **Globale uniciteit** – U kunt gegevens uit verschillende databases samenvoegen zonder conflicten
- **Beveiliging** – In tegenstelling tot sequentiële ID’s (1, 2, 3…) kunnen de volgende waarden niet worden geraden
- **Gedistribueerde systemen** – UUID’s kunnen onafhankelijk op meerdere servers worden gegenereerd zonder coördinatie
- **Database samenvoegen** – Bij het samenvoegen van twee databases ontstaan er geen conflicten

**Nadelen:**

- Grotere omvang (16 bytes vs 4-8 bytes voor integer)
- Langzamere indexering in sommige databases (gebruik v6/v7 voor betere prestaties)
- Minder leesbaar voor mensen

### API en Web Services

- **REST API** – Unieke identificaties voor resources
- **GraphQL** – Globale identificaties voor nodes
- **Webhooks** – Tracking van verzoeken en antwoorden
- **Tokens** – Sessie-ID’s, refresh-tokens

### Bestanden en Opslag

- **Bestandsnamen** – Voorkomen van botsingen bij het uploaden
- **S3/Cloud Storage** – Unieke paden naar objecten
- **Cache keys** – Identificaties in cachesystemen

### Frontend Toepassingen

- **React/Vue componenten** – Unieke keys voor lijsten
- **Tijdelijke ID’s** – ID’s voordat ze in de database worden opgeslagen
- **Lokale opslag** – Sleutels voor opgeslagen gegevens
- **Offline-first applicaties** – Genereren van ID’s zonder serververbinding

## Geavanceerde Functies van de Generator

### UUID genereren met een aangepaste tijd

Voor tijdsgebaseerde versies (v1, v6, v7) kunt u elke tijdstempel selecteren met behulp van de datum-tijdkiezer. Dit is handig voor:

**Testen:**

- Simuleren van in het verleden aangemaakte UUID’s
- Testen van tijdssortering in databases
- Reproduceren van UUID’s voor debugging

**Datamigratie:**

- Genereren van UUID’s met historische tijdstempels
- Backfilling van gegevens met correcte tijdstempelwaarden
- Importeren van gegevens uit verschillende tijdsperioden

**Auditing en compliance:**

- Reconstructie van UUID’s op basis van de aanmaaktijd van een record
- Retroactief genereren van identificaties

**Voorbeeld van gebruik:**

1. Selecteer versie v1, v6 of v7
2. Stel de datum en tijd in met de datum-tijdkiezer
3. Genereer UUID met uw eigen tijdstempel

### Hash-gebaseerde UUID (v3, v5)

Voor deterministische UUID’s kunt u versie v3 (MD5) of v5 (SHA-1) gebruiken:

**Hoe te gebruiken:**

1. Selecteer de naamruimte op basis van het type van uw identificatie
2. Voer de naam/waarde in
3. Genereer de UUID

**Voorbeelden:**

| Naamruimte | Naam (invoer) | Gebruik |
| --- | --- | --- |
| DNS | `example.com` | Conversie van domeinnaam naar UUID |
| DNS | `google.com` | Elke website heeft een unieke UUID |
| URL | `https://example.com/page` | Conversie van URL naar UUID |
| URL | `https://api.example.com/users/123` | API-eindpunt als UUID |
| OID | `1.3.6.1.4.1.343` | Object Identifier naar UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name naar UUID |

**Belangrijke kenmerken:**

- ✅ **Deterministisch**: Zelfde invoer = altijd dezelfde UUID
- ✅ **Reproduceerbaar**: U kunt de UUID altijd opnieuw aanmaken
- ✅ **Consistent**: Dezelfde UUID in verschillende systemen
- ❌ **Kan niet worden gedecodeerd**: Uit de UUID kan de oorspronkelijke naam niet worden herleid
- ℹ️ **Eén UUID**: Voor v3/v5 wordt altijd slechts één UUID gegenereerd (zelfde invoer = zelfde uitvoer)

**Praktisch gebruik:**

```
// Voorbeeld: Conversie van URL naar UUID v5
Naamruimte: URL
Naam: https://example.com/api/users/123
Resultaat: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Zelfde invoer = altijd dezelfde UUID
Naamruimte: DNS
Naam: google.com
Resultaat: altijd dezelfde UUID voor google.com
```

## Hoe UUID veilig te gebruiken?

### Cryptografische Beveiliging

Onze generator gebruikt `crypto.getRandomValues()`, wat een cryptografisch veilige generator voor willekeurige getallen is. In tegenstelling tot `Math.random()`, dat voorspelbaar is en ongeschikt voor beveiligingsdoeleinden, biedt `crypto.getRandomValues()` echte entropie die geschikt is voor:

- Genereren van beveiligingstokens
- Sessie-ID’s
- API-sleutels
- Cryptografische toepassingen

### Vergelijking van UUID-versies

| Versie | Basis | Botsingen | Tijdssortering | DB-prestaties | Gebruik |
| --- | --- | --- | --- | --- | --- |
| v1 | Tijdstempel + MAC | Laag | ✅ Ja | ❌ Slechter | Verouderd, audit |
| v3 | MD5-hash | Geen (deterministisch) | ❌ Nee | ⚠️ Gemiddeld | Conversies (verouderd) |
| v4 | Willekeurig | Extreem laag | ❌ Nee | ⚠️ Gemiddeld | Algemeen gebruik |
| v5 | SHA-1-hash | Geen (deterministisch) | ❌ Nee | ⚠️ Gemiddeld | Conversies (aanbevolen) |
| v6 | Gesorteerde tijdstempel | Laag | ✅ Ja | ✅ Beter | Moderne DB met tijd |
| v7 | Unix tijdstempel | Laag | ✅ Ja | ✅ Beste | Nieuwe projecten |

### UUID vs andere identificaties

| Type | Grootte | Botsingen | Tijdssortering | Gebruik |
| --- | --- | --- | --- | --- |
| Auto-increment ID | 4-8 bytes | Gegarandeerd uniek binnen tabel | ❌ | Eenvoudige toepassingen, lokale DB |
| UUID v4 | 16 bytes | Praktisch onmogelijk | ❌ | Gedistribueerde systemen, API |
| UUID v7 | 16 bytes | Praktisch onmogelijk | ✅ | Moderne DB met prestaties |
| ULID | 16 bytes | Praktisch onmogelijk | ✅ | UUID + lexicografische sortering |
| Snowflake ID | 8 bytes | Gegarandeerd uniek bij juiste configuratie | ✅ | Twitter, gedistribueerde systemen |
| NanoID | Configureerbaar | Afhankelijk van lengte | ❌ | URL-vriendelijke ID’s |

## Implementatie in verschillende talen

### JavaScript/TypeScript

```
// UUID v4 - Eenvoudigste manier (moderne browsers)
const uuid = crypto.randomUUID();

// UUID v4 - Handmatige implementatie
function generateUUIDv4() {
  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
    const r = (crypto.getRandomValues(new Uint8Array(1))[0] & 0x0f) >> (c === 'x' ? 0 : 2);
    const v = c === 'x' ? r : (r & 0x3) | 0x8;
    return v.toString(16);
  });
}

// UUID v7 - Aanbevolen voor databases
function generateUUIDv7() {
  const timestamp = Date.now();
  const timeHi = (timestamp >> 16).toString(16).padStart(8, '0');
  const timeLow = (timestamp & 0xFFFF).toString(16).padStart(4, '0');

  const randomBytes = crypto.getRandomValues(new Uint8Array(10));
  const randomHex = Array.from(randomBytes)
    .map(b => b.toString(16).padStart(2, '0'))
    .join('');

  return `${timeHi}-${timeLow}-7${randomHex.substr(0, 3)}-${randomHex.substr(3, 4)}-${randomHex.substr(7)}`;
}
```

### Python

```
import uuid

# UUID v4
uuid_v4 = str(uuid.uuid4())
# Output: '6ba7b810-9dad-11d1-80b4-00c04fd430c8'

# UUID v1
uuid_v1 = str(uuid.uuid1())
```

### Java

```
import java.util.UUID;

// UUID v4
String uuidV4 = UUID.randomUUID().toString();
```

### PHP

```
// UUID v4 (PHP 7+)
function generateUUID() {
    return sprintf('%04x%04x-%04x-%04x-%04x-%04x%04x%04x',
        mt_rand(0, 0xffff), mt_rand(0, 0xffff),
        mt_rand(0, 0xffff),
        mt_rand(0, 0x0fff) | 0x4000,
        mt_rand(0, 0x3fff) | 0x8000,
        mt_rand(0, 0xffff), mt_rand(0, 0xffff), mt_rand(0, 0xffff)
    );
}
```

### C#

```
using System;

// UUID v4
Guid uuid = Guid.NewGuid();
string uuidString = uuid.ToString();
```

## Best Practices

### UUID opslaan in de database

**PostgreSQL:**

```
CREATE TABLE users (
    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT NOW()
);
```

**MySQL 8.0+:**

```
CREATE TABLE users (
    id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
    email VARCHAR(255) NOT NULL,
    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
);
```

**Tip:** In MySQL slaat u UUID op als `BINARY(16)` in plaats van `CHAR(36)` om ruimte te besparen en sneller te indexeren.

### UUID Validatie

```
function isValidUUID(uuid) {
  const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
  return regex.test(uuid);
}
```

### UUID Conversie

```
// Koppelteken verwijderen
const compact = uuid.replace(/-/g, '');

// Koppelteken terug toevoegen
function formatUUID(compactUuid) {
  return [
    compactUuid.substring(0, 8),
    compactUuid.substring(8, 12),
    compactUuid.substring(12, 16),
    compactUuid.substring(16, 20),
    compactUuid.substring(20, 32)
  ].join('-');
}
```

## Probleemoplossing (Troubleshooting)

### UUID v3/v5 werkt niet

**Probleem:** Na het selecteren van v3 of v5 wordt er niets gegenereerd

**Oplossing:**

1. ✅ Controleer of u het veld “Naam” heeft **ingevuld** - dit is verplicht!
2. ✅ Selecteer de juiste naamruimte op basis van het type van uw invoer
3. ✅ Voorbeelden van geldige invoeren:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Elke tekst: `mijn-applicatie-v1`

**Tip:** Probeer eerst een eenvoudige waarde zoals `test` en naamruimte DNS.

### Tijdsgebaseerde UUID (v1, v6, v7) heeft een vreemde tijd

**Probleem:** De gegenereerde UUID heeft een onverwachte tijdstempel

**Oplossing:**

1. ✅ Controleer de datum-tijdkiezer - is de juiste tijd ingesteld?
2. ✅ De datum-tijdkiezer gebruikt uw lokale tijdzone
3. ✅ Laat de datum-tijdkiezer leeg voor de huidige tijd

### UUID kan niet worden gekopieerd

**Probleem:** De knop “Kopieer alles” werkt niet

**Oplossing:**

1. ✅ Controleer of u UUID’s heeft gegenereerd (ze zijn niet leeg)
2. ✅ Sommige browsers vereisen HTTPS voor de clipboard API
3. ✅ Selecteer anders de tekst in het tekstgebied en kopieer handmatig (Ctrl+C)

## Veelgestelde Vragen (FAQ)

### Kan er een UUID-botsing optreden?

Theoretisch wel, maar de kans is astronomisch klein. Bij het genereren van 1 miljard UUID v4 per seconde gedurende 100 jaar is de kans op een botsing ongeveer 0,00000006%. In de praktijk zal een botsing nooit optreden.

### Is UUID geschikt als primaire sleutel in een database?

Dat hangt af van het gebruik. UUID is ideaal voor gedistribueerde systemen en situaties waarin u globale uniciteit nodig heeft. Voor eenvoudige applicaties met één database kan auto-increment efficiënter zijn.

### Zijn de UUID's die met deze tool zijn gegenereerd veilig?

Ja, we gebruiken de Web Crypto API (\`crypto.getRandomValues()\`), die cryptografisch veilige willekeurige waarden levert. Alles gebeurt lokaal in uw browser.

### Wat is het verschil tussen UUID-versies?

\- \*\*v1\*\*: Tijdstempel + MAC/willekeurig - chronologische sortering, slechtere DB-prestaties - \*\*v3/v5\*\*: Hash-gebaseerd - deterministisch, voor de conversie van bekende identificaties - \*\*v4\*\*: Willekeurig - het veiligst, meest gebruikt - \*\*v6\*\*: Omgezet tijdstempel - betere DB-prestaties dan v1 - \*\*v7\*\*: Unix tijdstempel - de beste DB-prestaties + tijdssortering

### Welke UUID-versie moet ik gebruiken?

Voor de meeste gevallen gebruikt u \*\*v4\*\* (willekeurig). Voor databases met tijdssortering gebruikt u \*\*v7\*\* (modern) of \*\*v6\*\* (standaard). Voor de conversie van bekende identificaties (URL, DNS) gebruikt u \*\*v5\*\* (SHA-1).

### Kan ik UUID gebruiken voor tokens en API-sleutels?

UUID v4 is geschikt voor sessie-ID's en vergelijkbare tokens. Voor API-sleutels kunt u overwegen langere willekeurige strings te gebruiken (bijv. 256-bits waarden) of gespecialiseerde bibliotheken.

### Hoe groot zijn UUID's?

Een UUID is 128 bits (16 bytes). In stringformaat met koppeltekens neemt het 36 tekens in beslag. Zonder koppeltekens 32 hexadecimale tekens.

## Alternatieven voor UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- 128-bits ID (hetzelfde als UUID)
- Lexicografisch sorteerbaar op aanmaaktijd
- Compactere weergave (26 tekens in plaats van 36)
- Hoofdletterongevoelige base32-codering

**Voorbeeld:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Kleiner dan UUID (standaard 21 tekens)
- URL-vriendelijk (geen speciale tekens)
- Snellere generatie
- Configureerbare lengte en alfabet

**Voorbeeld:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- 64-bits ID (kleiner dan UUID)
- Tijdssorteerbaar
- Bevat worker ID en sequentienummer
- Vereist gecentraliseerde configuratie

**Voorbeeld:** `1234567890123456789`

## Prestaties en Optimalisatie

### Generatiesnelheid

Onze generator kan genereren:

- **1 UUID:** < 1 ms
- **100 UUID:** ~10-20 ms
- **1000 UUID:** ~100-200 ms

### Prestatie Tips

1. **Batch genereren** – Als u veel UUID’s nodig heeft, genereer ze dan tegelijk in plaats van één voor één
2. **Opslaan in DB** – Indexeer UUID-kolommen voor snel zoeken
3. **Compressie** – Sla UUID op in binaire vorm (16 bytes) in plaats van een string (36 bytes)
4. **Caching** – In sommige gevallen kunt u UUID’s vooraf genereren en cachen

## Voor Ontwikkelaars

### Structuur van UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits willekeurige data (node)
|        |    |    └────── 16 bits willekeurige data met variant (clock_seq)
|        |    └─────────── 12 bits willekeurige data + 4 bits versie (time_hi_and_version)
|        └──────────────── 16 bits willekeurige data (time_mid)
└───────────────────────── 32 bits willekeurige data (time_low)
```

- Versie (4 bits): altijd `0100` (binair) = `4` (hex)
- Variant (2-3 bits): altijd `10` (binair) voor RFC 4122

### UUID Testen

```
// Jest test
describe('UUID Generator', () => {
  test('generates valid UUID v4', () => {
    const uuid = generateUUIDv4();
    const regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
    expect(regex.test(uuid)).toBe(true);
  });

  test('generates unique UUIDs', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});
```

## Beveiligingsaspecten

### Wat u niet moet doen met UUID

❌ **Gebruik UUID v1 niet voor gevoelige applicaties** – Bevat een tijdstempel, wat een beveiligingsrisico kan zijn

❌ **Gebruik `Math.random()` niet voor het genereren van UUID** – Dit is niet cryptografisch veilig

❌ **Vertrouw niet op UUID voor autorisatie** – UUID kan worden geraden (zij het met een extreem kleine kans)

❌ **Sla UUID niet op in cookies zonder versleuteling** – Gebruik gesigneerde cookies of JWT

### Wat u wel moet doen

✅ **Gebruik UUID v4 voor de meeste gevallen** – Hoogste entropie en veiligheid

✅ **Combineer UUID met andere beveiligingsmaatregelen** – Voor sessiebeheer, gebruik HTTPS, HttpOnly cookies en een korte vervaldatum

✅ **Valideer UUID op de server** – Controleer altijd het formaat en de versie van de UUID

✅ **Gebruik cryptografisch veilige bronnen van willekeurigheid** – `crypto.getRandomValues()` in de browser, `/dev/urandom` op Linux

## Interessante Feiten

- **Aantal mogelijke UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undeciljoenen)
- **Noodzakelijke botsing:** Voor 50% kans op een botsing moet u 2.71 × 10^18 UUID’s genereren (2.71 quintiljoenen)
- **Grootte van alle mogelijke UUID’s:** Als we elke UUID als 16 bytes zouden opslaan, zou de hele ruimte 85 zettabytes in beslag nemen (85 miljard terabytes)
- **Oorsprong:** UUID werd gestandaardiseerd als onderdeel van DCE (Distributed Computing Environment) in 1990

## Other languages

- Čeština (cs): [Generátor UUID](https://acrafto.com/cs/generator-uuid/) ([Markdown](https://acrafto.com/cs/generator-uuid/index.md))
- Slovenčina (sk): [UUID generátor](https://acrafto.com/sk/generator-uuid/) ([Markdown](https://acrafto.com/sk/generator-uuid/index.md))
- English (en): [UUID Generator](https://acrafto.com/en/uuid-generator/) ([Markdown](https://acrafto.com/en/uuid-generator/index.md))
- Deutsch (de): [UUID Generator](https://acrafto.com/de/uuid-generator/) ([Markdown](https://acrafto.com/de/uuid-generator/index.md))
- Français (fr): [Générateur UUID](https://acrafto.com/fr/generateur-uuid/) ([Markdown](https://acrafto.com/fr/generateur-uuid/index.md))
- Español (es): [Generador de UUID](https://acrafto.com/es/generador-uuid/) ([Markdown](https://acrafto.com/es/generador-uuid/index.md))
- Italiano (it): [Generatore UUID](https://acrafto.com/it/generatore-uuid/) ([Markdown](https://acrafto.com/it/generatore-uuid/index.md))
- Português (pt): [Gerador de UUID](https://acrafto.com/pt/gerador-uuid/) ([Markdown](https://acrafto.com/pt/gerador-uuid/index.md))
- Polski (pl): [Generator UUID](https://acrafto.com/pl/generator-uuid/) ([Markdown](https://acrafto.com/pl/generator-uuid/index.md))
- Română (ro): [Generator UUID](https://acrafto.com/ro/generator-uuid/) ([Markdown](https://acrafto.com/ro/generator-uuid/index.md))
- Magyar (hu): [UUID generátor](https://acrafto.com/hu/uuid-generator/) ([Markdown](https://acrafto.com/hu/uuid-generator/index.md))
- Ελληνικά (el): [Γεννήτρια UUID](https://acrafto.com/el/gennitria-uuid/) ([Markdown](https://acrafto.com/el/gennitria-uuid/index.md))
- Български (bg): [UUID генератор](https://acrafto.com/bg/uuid-generator/) ([Markdown](https://acrafto.com/bg/uuid-generator/index.md))
- Hrvatski (hr): [Generator UUID](https://acrafto.com/hr/generator-uuid/) ([Markdown](https://acrafto.com/hr/generator-uuid/index.md))
- Slovenščina (sl): [UUID generator](https://acrafto.com/sl/generator-uuid/) ([Markdown](https://acrafto.com/sl/generator-uuid/index.md))
- Eesti (et): [UUID generaator](https://acrafto.com/et/uuid-generaator/) ([Markdown](https://acrafto.com/et/uuid-generaator/index.md))
- Latviešu (lv): [UUID ģenerators](https://acrafto.com/lv/uuid-generator/) ([Markdown](https://acrafto.com/lv/uuid-generator/index.md))
- Lietuvių (lt): [UUID generatorius](https://acrafto.com/lt/uuid-generatorius/) ([Markdown](https://acrafto.com/lt/uuid-generatorius/index.md))
- Svenska (sv): [UUID-generator](https://acrafto.com/sv/uuid-generator/) ([Markdown](https://acrafto.com/sv/uuid-generator/index.md))
- Dansk (da): [UUID generator](https://acrafto.com/da/uuid-generator/) ([Markdown](https://acrafto.com/da/uuid-generator/index.md))
- Suomi (fi): [UUID-generaattori](https://acrafto.com/fi/uuid-generaattori/) ([Markdown](https://acrafto.com/fi/uuid-generaattori/index.md))
- Norsk (no): [UUID-generator](https://acrafto.com/no/uuid-generator/) ([Markdown](https://acrafto.com/no/uuid-generator/index.md))
- Українська (uk): [Генератор UUID](https://acrafto.com/uk/henerator-uuid/) ([Markdown](https://acrafto.com/uk/henerator-uuid/index.md))
- Русский (ru): [Генератор UUID](https://acrafto.com/ru/generator-uuid/) ([Markdown](https://acrafto.com/ru/generator-uuid/index.md))
- Српски (sr): [UUID generator](https://acrafto.com/sr/uuid-generator/) ([Markdown](https://acrafto.com/sr/uuid-generator/index.md))
- Македонски (mk): [UUID генератор](https://acrafto.com/mk/uuid-generator/) ([Markdown](https://acrafto.com/mk/uuid-generator/index.md))
- Bosanski (bs): [Generator UUID-a](https://acrafto.com/bs/generator-uuid/) ([Markdown](https://acrafto.com/bs/generator-uuid/index.md))
- Shqip (sq): [Gjenerator UUID](https://acrafto.com/sq/gjenerator-uuid/) ([Markdown](https://acrafto.com/sq/gjenerator-uuid/index.md))
- Türkçe (tr): [UUID oluşturucu](https://acrafto.com/tr/uuid-uretici/) ([Markdown](https://acrafto.com/tr/uuid-uretici/index.md))
- 日本語 (ja): [UUID生成ツール](https://acrafto.com/ja/uuid-generator/) ([Markdown](https://acrafto.com/ja/uuid-generator/index.md))
- 한국어 (ko): [UUID 생성기](https://acrafto.com/ko/uuid-generator/) ([Markdown](https://acrafto.com/ko/uuid-generator/index.md))
- العربية (ar): [مولد UUID](https://acrafto.com/ar/uuid-generator/) ([Markdown](https://acrafto.com/ar/uuid-generator/index.md))
- हिन्दी (hi): [UUID जनरेटर](https://acrafto.com/hi/uuid-generator/) ([Markdown](https://acrafto.com/hi/uuid-generator/index.md))
- Bahasa Indonesia (id): [Generator UUID](https://acrafto.com/id/generator-uuid/) ([Markdown](https://acrafto.com/id/generator-uuid/index.md))
- Tiếng Việt (vi): [Trình tạo UUID](https://acrafto.com/vi/uuid-generator/) ([Markdown](https://acrafto.com/vi/uuid-generator/index.md))
- ไทย (th): [สร้าง UUID](https://acrafto.com/th/uuid-generator/) ([Markdown](https://acrafto.com/th/uuid-generator/index.md))
- עברית (he): [מחולל UUID](https://acrafto.com/he/uuid-generator/) ([Markdown](https://acrafto.com/he/uuid-generator/index.md))