# Generatore UUID

> Genera UUID gratis online: tutte le versioni (v1, v3-v7) supportate. Crea migliaia di identificatori univoci contemporaneamente, nel browser.

URL: https://acrafto.com/it/generatore-uuid/

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.

## Cos’è un UUID?

Un UUID (Universally Unique Identifier) è un identificatore a 128 bit utilizzato nei sistemi informatici per identificare in modo univoco le informazioni. L’UUID è standardizzato secondo RFC 4122 e, grazie alla sua enorme entropia, garantisce una probabilità di collisione praticamente nulla – ciò significa che due UUID generati indipendentemente saranno quasi certamente unici.

L’UUID ha un formato standard: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, dove ogni `x` è una cifra esadecimale (0-9, a-f), `M` indica la versione dell’UUID e `N` indica la variante.

## Versioni di UUID

### UUID v1 (Timestamp + indirizzo MAC)

UUID v1 si basa sul timestamp corrente e su un valore casuale (nel browser, invece dell’indirizzo MAC). Utilizza intervalli di 100 nanosecondi a partire dal 15 ottobre 1582 (Calendario Gregoriano).

**Utilizzo:**

- Situazioni in cui è necessario ordinare gli UUID cronologicamente
- Debugging e logging (l’UUID contiene informazioni sul tempo di creazione)
- Sistemi distribuiti con sincronizzazione temporale

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

**Vantaggi:**

- Gli UUID possono essere ordinati cronologicamente in base al tempo di creazione
- Utile per audit e debugging
- Contiene informazioni sul timestamp

**Svantaggi:**

- Potenziale rischio per la sicurezza – contiene il timestamp
- Nel browser non contiene l’indirizzo MAC effettivo (sostituito da un valore casuale)
- Scarsa località del DB (il timestamp è nei bit di ordine inferiore)

### UUID v3 (Hash MD5)

UUID v3 è generato utilizzando l’hash MD5 del namespace UUID e del nome. Deterministico – lo stesso namespace + nome genererà sempre lo stesso UUID.

**Utilizzo:**

- Conversione di URL, nomi DNS o altri identificatori in UUID
- Situazioni in cui sono necessari UUID riproducibili
- Mappatura tra diversi sistemi di identificazione

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

**Vantaggi:**

- Deterministico (stesso input = stesso output)
- Ideale per la conversione di identificatori noti
- Nessuna collisione per input diversi

**Svantaggi:**

- MD5 è un algoritmo obsoleto (preferire v5)
- Richiede namespace e nome
- Impossibile recuperare l’input originale

### UUID v4 (Casuale) - RACCOMANDATO

La versione di UUID più utilizzata. UUID v4 è generato puramente in modo casuale utilizzando un generatore di numeri casuali crittograficamente sicuro (`crypto.getRandomValues()`).

**Utilizzo:**

- Chiavi primarie del database
- Identificatori di sessione (session IDs)
- Nomi di file unici
- Token API
- Scopi generali in cui è necessario un ID garantito unico

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

**Vantaggi:**

- Massima entropia e sicurezza
- Nessuna dipendenza dal tempo o dai parametri di sistema
- Implementazione più semplice

**Probabilità di collisione:** Generando 1 miliardo di UUID al secondo per 100 anni, la probabilità di collisione è di circa 0,00000006%.

### UUID v5 (Hash SHA-1)

UUID v5 è uguale a v3, ma utilizza SHA-1 invece di MD5. Un’alternativa più moderna e sicura a v3.

**Utilizzo:**

- Uguale a v3, ma con maggiore sicurezza
- Preferito a v3 per i nuovi progetti
- Generazione di UUID da URL, nomi DNS, OID, X.500 DN

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

**Vantaggi:**

- Deterministico
- SHA-1 è più robusto di MD5
- Adatto per la mappatura tra sistemi

**Svantaggi:**

- Anche SHA-1 è considerato obsoleto (ma comunque più sicuro di MD5)
- Richiede namespace e nome

### UUID v6 (Timestamp ordinato)

UUID v6 è una versione migliorata di v1 con bit temporali riorganizzati per una migliore indicizzazione del DB. Progettato per risolvere problemi di località nei database.

**Utilizzo:**

- Chiavi primarie del database con ordinamento temporale
- Sistemi che richiedono sia l’ordinamento cronologico che le prestazioni del DB
- Alternativa più moderna a v1

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

**Vantaggi:**

- Migliore località del DB rispetto a v1 (timestamp nei bit di ordine superiore)
- Ordinamento cronologico
- Compatibile con lo standard UUID

**Svantaggi:**

- Meno utilizzato rispetto a v1/v4
- Contiene ancora informazioni temporali (rischio per la sicurezza)

### UUID v7 (Timestamp Unix)

UUID v7 utilizza il timestamp Unix (millisecondi dal 1970) + bit casuali. La versione più recente di UUID con la migliore località del DB.

**Utilizzo:**

- Chiavi primarie del database moderne
- Sistemi che richiedono performance + ordinamento temporale
- Sostituzione di v1/v6 nei nuovi progetti

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

**Vantaggi:**

- Migliore località del DB di tutte le versioni
- Il timestamp Unix è standard
- Combina i vantaggi della casualità e dell’ordinamento temporale

**Svantaggi:**

- Specificazione relativamente nuova (RFC 4122bis)
- Meno supportata nei sistemi legacy

## Quale versione di UUID usare?

### Guida decisionale

**Hai bisogno della massima sicurezza e casualità?** → Usa **UUID v4** (la scelta più comune)

**Hai bisogno di ordinamento temporale e performance del DB?** → Usa **UUID v7** (moderno) o **UUID v6** (standard)

**Hai bisogno di UUID riproducibili da identificatori esistenti?** → Usa **UUID v5** (SHA-1) o **UUID v3** (MD5, legacy)

**Hai bisogno di un timestamp e di una traccia di audit?** → Usa **UUID v1** (legacy, peggiori performance del DB)

### Database

**Per i nuovi progetti:** UUID v7 o v4

- **v7** è ideale per l’ordinamento temporale + performance
- **v4** per la massima casualità senza informazioni temporali

**Per i sistemi legacy:** UUID v1 o v6

- **v6** ha una migliore località del DB rispetto a v1
- **v1** è ampiamente supportato

**Vantaggi degli UUID come chiave primaria:**

- **Unicità globale** – Puoi unire dati da diversi database senza conflitti
- **Sicurezza** – A differenza degli ID sequenziali (1, 2, 3…) non è possibile indovinare i valori successivi
- **Sistemi distribuiti** – Gli UUID possono essere generati indipendentemente su più server senza coordinamento
- **Unione di database** – Durante l’unione di due database non sorgono conflitti

**Svantaggi:**

- Dimensione maggiore (16 byte vs 4-8 byte per un intero)
- Indicizzazione più lenta in alcuni database (usa v6/v7 per migliori performance)
- Meno leggibile per l’uomo

### API e Servizi Web

- **REST API** – Identificatori univoci per le risorse
- **GraphQL** – Identificatori globali per i nodi
- **Webhook** – Tracciamento di richieste e risposte
- **Token** – ID di sessione, token di refresh

### File e Archiviazione

- **Nomi di file** – Prevenzione delle collisioni durante l’upload
- **S3/Cloud Storage** – Percorsi univoci per gli oggetti
- **Chiavi di cache** – Identificatori nei sistemi di cache

### Applicazioni Frontend

- **Componenti React/Vue** – Chiavi uniche per le liste
- **ID temporanei** – ID prima del salvataggio nel database
- **Local storage** – Chiavi per i dati salvati
- **Applicazioni offline-first** – Generazione di ID senza connessione al server

## Funzionalità Avanzate del Generatore

### Generazione di UUID con timestamp personalizzato

Per le versioni basate sul tempo (v1, v6, v7) puoi selezionare un timestamp arbitrario utilizzando il selettore data-ora. Questo è utile per:

**Test:**

- Simulazione di UUID creati in passato
- Test dell’ordinamento temporale nei database
- Riproduzione di UUID per il debugging

**Migrazione dati:**

- Generazione di UUID con timestamp storici
- Inserimento di dati con valori di timestamp corretti
- Importazione di dati da diversi periodi di tempo

**Audit e conformità:**

- Ricostruzione di UUID in base al tempo di creazione del record
- Generazione retroattiva di identificatori

**Esempio di utilizzo:**

1. Seleziona la versione v1, v6 o v7
2. Imposta data e ora utilizzando il selettore data-ora
3. Genera UUID con il tuo timestamp personalizzato

### UUID basati su Hash (v3, v5)

Per UUID deterministici puoi usare le versioni v3 (MD5) o v5 (SHA-1):

**Come usare:**

1. Seleziona il namespace in base al tipo del tuo identificatore
2. Inserisci il nome/valore
3. Genera l’UUID

**Esempi:**

| Namespace | Nome (input) | Utilizzo |
| --- | --- | --- |
| DNS | `example.com` | Conversione di un nome di dominio in UUID |
| DNS | `google.com` | Ogni sito web ha un UUID unico |
| URL | `https://example.com/page` | Conversione di un URL in UUID |
| URL | `https://api.example.com/users/123` | Endpoint API come UUID |
| OID | `1.3.6.1.4.1.343` | Identificatore di Oggetto in UUID |
| X.500 | `CN=John Doe,O=Company` | Distinguished Name in UUID |

**Proprietà importanti:**

- ✅ **Deterministico**: Stesso input = sempre stesso UUID
- ✅ **Riproducibile**: Puoi ricreare l’UUID in qualsiasi momento
- ✅ **Consistente**: Stesso UUID tra diversi sistemi
- ❌ **Non decodificabile**: Dal UUID non è possibile recuperare il nome originale
- ℹ️ **Un solo UUID**: Per v3/v5 viene generato sempre un solo UUID (stesso input = stesso output)

**Uso pratico:**

```
// Esempio: Conversione di URL in UUID v5
Namespace: URL
Nome: https://example.com/api/users/123
Risultato: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Stesso input = sempre lo stesso UUID
Namespace: DNS
Nome: google.com
Risultato: sempre lo stesso UUID per google.com
```

## Come usare gli UUID in sicurezza?

### Sicurezza Crittografica

Il nostro generatore utilizza `crypto.getRandomValues()`, un generatore di numeri casuali crittograficamente sicuro. A differenza di `Math.random()`, che è prevedibile e inadatto a scopi di sicurezza, `crypto.getRandomValues()` fornisce vera entropia adatta per:

- Generazione di token di sicurezza
- ID di sessione
- Chiavi API
- Applicazioni crittografiche

### Confronto delle versioni UUID

| Versione | Base | Collisione | Ordinamento temporale | Performance DB | Utilizzo |
| --- | --- | --- | --- | --- | --- |
| v1 | Timestamp + MAC | Bassa | ✅ Sì | ❌ Peggiore | Legacy, audit |
| v3 | Hash MD5 | Nessuna (deterministico) | ❌ No | ⚠️ Media | Conversioni (legacy) |
| v4 | Casuale | Estremamente bassa | ❌ No | ⚠️ Media | Uso generale |
| v5 | Hash SHA-1 | Nessuna (deterministico) | ❌ No | ⚠️ Media | Conversioni (raccomandato) |
| v6 | Timestamp ordinato | Bassa | ✅ Sì | ✅ Migliore | DB moderni con tempo |
| v7 | Timestamp Unix | Bassa | ✅ Sì | ✅ Migliore | Nuovi progetti |

### UUID vs altri identificatori

| Tipo | Dimensione | Collisione | Ordinamento temporale | Utilizzo |
| --- | --- | --- | --- | --- |
| ID auto-incrementale | 4-8 byte | Garantito unico nella tabella | ❌ | Applicazioni semplici, DB locali |
| UUID v4 | 16 byte | Praticamente impossibile | ❌ | Sistemi distribuiti, API |
| UUID v7 | 16 byte | Praticamente impossibile | ✅ | DB moderni con performance |
| ULID | 16 byte | Praticamente impossibile | ✅ | UUID + ordinamento lessicografico |
| Snowflake ID | 8 byte | Garantito unico con configurazione corretta | ✅ | Twitter, sistemi distribuiti |
| NanoID | Configurabile | Dipende dalla lunghezza | ❌ | ID URL-friendly |

## Implementazione in diversi linguaggi

### JavaScript/TypeScript

```
// UUID v4 - Il modo più semplice (browser moderni)
const uuid = crypto.randomUUID();

// UUID v4 - Implementazione manuale
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 - Raccomandato per i database
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();
```

## Migliori Pratiche

### Salvataggio di UUID nel 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
);
```

**Suggerimento:** In MySQL, salva gli UUID come `BINARY(16)` invece di `CHAR(36)` per risparmiare spazio e velocizzare l’indicizzazione.

### Validazione UUID

```
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);
}
```

### Conversione UUID

```
// Rimozione dei trattini
const compact = uuid.replace(/-/g, '');

// Aggiunta dei trattini
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('-');
}
```

## Risoluzione dei Problemi (Troubleshooting)

### UUID v3/v5 non funziona

**Problema:** Dopo aver selezionato v3 o v5, non viene generato nulla

**Soluzione:**

1. ✅ Verifica di aver **compilato il campo “Nome”** - è obbligatorio!
2. ✅ Seleziona il namespace corretto in base al tipo del tuo input
3. ✅ Esempi di input validi:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Qualsiasi testo: `la-mia-applicazione-v1`

**Suggerimento:** Prova prima un valore semplice come `test` e il namespace DNS.

### UUID temporale (v1, v6, v7) ha un orario strano

**Problema:** L’UUID generato ha un timestamp inaspettato

**Soluzione:**

1. ✅ Controlla il selettore data-ora - è impostato l’orario corretto?
2. ✅ Il selettore data-ora utilizza il fuso orario locale
3. ✅ Lascia vuoto il selettore data-ora per l’ora corrente

### UUID non copiabile

**Problema:** Il pulsante “Copia tutto” non funziona

**Soluzione:**

1. ✅ Verifica di aver generato UUID (non sono vuoti)
2. ✅ Alcuni browser richiedono HTTPS per l’API degli appunti
3. ✅ In alternativa, seleziona il testo nell’area di testo e copia manualmente (Ctrl+C)

## Domande Frequenti (FAQ)

### Possono verificarsi collisioni UUID?

Teoricamente sì, ma la probabilità è astronomicamente piccola. Generando 1 miliardo di UUID v4 al secondo per 100 anni, la probabilità di collisione è di circa 0,00000006%. In pratica, una collisione non si verifica mai.

### L'UUID è adatto come chiave primaria in un database?

Dipende dal caso d'uso. L'UUID è ideale per sistemi distribuiti e situazioni in cui è necessaria l'unicità globale. Per applicazioni semplici con un unico database, un ID auto-incrementale può essere più efficiente.

### Gli UUID generati con questo strumento sono sicuri?

Sì, utilizziamo l'API Web Crypto (\`crypto.getRandomValues()\`), che fornisce valori casuali crittograficamente sicuri. Tutto avviene localmente nel tuo browser.

### Qual è la differenza tra le versioni UUID?

\- \*\*v1\*\*: Timestamp + MAC/casuale - ordinamento cronologico, peggiori performance DB - \*\*v3/v5\*\*: Basati su hash - deterministici, per la conversione di identificatori noti - \*\*v4\*\*: Casuali - i più sicuri, i più utilizzati - \*\*v6\*\*: Timestamp riorganizzato - migliori performance DB rispetto a v1 - \*\*v7\*\*: Timestamp Unix - migliori performance DB + ordinamento temporale

### Quale versione di UUID dovrei usare?

Per la maggior parte dei casi, usa \*\*v4\*\* (casuale). Per i database con ordinamento temporale, usa \*\*v7\*\* (moderno) o \*\*v6\*\* (standard). Per la conversione di identificatori noti (URL, DNS), usa \*\*v5\*\* (SHA-1).

### Posso usare gli UUID per token e chiavi API?

UUID v4 è adatto per ID di sessione e token simili. Per le chiavi API, considera l'uso di stringhe casuali più lunghe (ad esempio, valori a 256 bit) o librerie specializzate.

### Quanto sono grandi gli UUID?

Un UUID ha 128 bit (16 byte). In formato stringa con trattini occupa 36 caratteri. Senza trattini, 32 caratteri esadecimali.

## Alternative agli UUID

### ULID (Universally Unique Lexicographically Sortable Identifier)

- ID a 128 bit (come UUID)
- Ordinabile lessicograficamente in base al tempo di creazione
- Rappresentazione più compatta (26 caratteri invece di 36)
- Codifica base32 case-insensitive

**Esempio:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Dimensioni minori rispetto agli UUID (21 caratteri standard)
- URL-friendly (senza caratteri speciali)
- Generazione più veloce
- Lunghezza e alfabeto configurabili

**Esempio:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- ID a 64 bit (più piccolo degli UUID)
- Ordinabile temporalmente
- Contiene ID del worker e numero di sequenza
- Richiede una configurazione centralizzata

**Esempio:** `1234567890123456789`

## Performance e Ottimizzazione

### Velocità di generazione

Il nostro generatore può generare:

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

### Consigli per le performance

1. **Generazione in batch** – Se hai bisogno di molti UUID, generane più di uno alla volta invece che singolarmente
2. **Salvataggio nel DB** – Indicizza le colonne UUID per una ricerca veloce
3. **Compressione** – Salva gli UUID in formato binario (16 byte) invece che stringa (36 byte)
4. **Caching** – In alcuni casi puoi pre-generare e cacheare gli UUID

## Per gli Sviluppatori

### Struttura UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bit di dati casuali (node)
|        |    |    └────── 16 bit di dati casuali con variante (clock_seq)
|        |    └─────────── 12 bit di dati casuali + 4 bit di versione (time_hi_and_version)
|        └──────────────── 16 bit di dati casuali (time_mid)
└───────────────────────── 32 bit di dati casuali (time_low)
```

- Versione (4 bit): sempre `0100` (binario) = `4` (hex)
- Variante (2-3 bit): sempre `10` (binario) per RFC 4122

### Test degli UUID

```
// Test Jest
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);
  });
});
```

## Aspetti di Sicurezza

### Cosa non fare con gli UUID

❌ **Non usare UUID v1 per applicazioni sensibili** – Contiene un timestamp, che può essere un rischio per la sicurezza

❌ **Non usare `Math.random()` per generare UUID** – Non è crittograficamente sicuro

❌ **Non fare affidamento sugli UUID per l’autorizzazione** – L’UUID può essere indovinato (anche se con probabilità estremamente bassa)

❌ **Non salvare gli UUID nei cookie senza crittografia** – Usa cookie firmati o JWT

### Cosa fare

✅ **Usa UUID v4 per la maggior parte dei casi** – Massima entropia e sicurezza

✅ **Combina gli UUID con altre misure di sicurezza** – Per la gestione delle sessioni usa HTTPS, cookie HttpOnly e una breve scadenza

✅ **Valida gli UUID sul server** – Controlla sempre il formato e la versione dell’UUID

✅ **Usa fonti di casualità crittograficamente sicure** – `crypto.getRandomValues()` nel browser, `/dev/urandom` su Linux

## Curiosità

- **Numero di possibili UUID v4:** 2^122 ≈ 5.3 × 10^36 (340 undecilioni)
- **Collisione necessaria:** Per avere il 50% di probabilità di collisione, devi generare 2.71 × 10^18 UUID (2.71 quintilioni)
- **Dimensione di tutti i possibili UUID:** Se salvassimo ogni UUID come 16 byte, l’intero spazio occuperebbe 85 zettabyte (85 miliardi di terabyte)
- **Origine:** L’UUID è stato standardizzato come parte del DCE (Distributed Computing Environment) nel 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))
- Português (pt): [Gerador de UUID](https://acrafto.com/pt/gerador-uuid/) ([Markdown](https://acrafto.com/pt/gerador-uuid/index.md))
- Nederlands (nl): [UUID generator](https://acrafto.com/nl/uuid-generator/) ([Markdown](https://acrafto.com/nl/uuid-generator/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))