# Gerador de UUID

> Gere UUIDs (Identificadores Universalmente Únicos) online, grátis. Suporta todas as versões (v1, v3-v7), com opção de gerar milhares de uma vez.

URL: https://acrafto.com/pt/gerador-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.

## O que é UUID?

UUID (Identificador Universalmente Único) é um identificador de 128 bits usado em sistemas de computador para identificar informações de forma única. O UUID é padronizado de acordo com a RFC 4122 e, devido à sua enorme entropia, garante uma probabilidade praticamente nula de colisão – o que significa que dois UUIDs gerados independentemente serão quase certamente únicos.

O UUID possui um formato padrão: `xxxxxxxx-xxxx-Mxxx-Nxxx-xxxxxxxxxxxx`, onde cada `x` é um dígito hexadecimal (0-9, a-f), `M` indica a versão do UUID e `N` indica a variante.

## Versões de UUID

### UUID v1 (Carimbo de Data/Hora + Endereço MAC)

O UUID v1 é baseado no carimbo de data/hora atual (timestamp) e um valor aleatório (no navegador, em vez do endereço MAC). Ele usa intervalos de 100 nanossegundos a partir de 15 de outubro de 1582 (calendário Gregoriano).

**Uso:**

- Situações em que você precisa de ordenação cronológica de UUIDs
- Depuração e registro (o UUID contém informações sobre o tempo de criação)
- Sistemas distribuídos com sincronização de tempo

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

**Vantagens:**

- UUIDs podem ser ordenados cronologicamente pelo tempo de criação
- Útil para auditoria e depuração
- Contém informações de carimbo de data/hora

**Desvantagens:**

- Potencial risco de segurança – contém carimbo de data/hora
- No navegador, não contém o endereço MAC real (substituído por um valor aleatório)
- Má localidade de DB (o carimbo de data/hora está nos bits de ordem baixa)

### UUID v3 (Hash MD5)

O UUID v3 é gerado usando o hash MD5 de um UUID de namespace e um nome. Determinístico – o mesmo namespace + nome sempre criará o mesmo UUID.

**Uso:**

- Conversão de URLs, nomes DNS ou outros identificadores para UUIDs
- Situações em que você precisa de UUIDs reproduzíveis
- Mapeamento entre diferentes sistemas de identificação

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

**Vantagens:**

- Determinístico (mesma entrada = mesma saída)
- Ideal para converter identificadores conhecidos
- Nenhuma colisão para diferentes entradas

**Desvantagens:**

- MD5 é um algoritmo obsoleto (prefira v5)
- Requer namespace e nome
- Não é possível recuperar a entrada original

### UUID v4 (Aleatório) - RECOMENDADO

A versão mais usada de UUID. O UUID v4 é gerado puramente aleatoriamente usando um gerador de números aleatórios criptograficamente seguro (`crypto.getRandomValues()`).

**Uso:**

- Chaves primárias de banco de dados
- Identificadores de sessão (IDs de sessão)
- Nomes de arquivo únicos
- Tokens de API
- Propósitos gerais onde você precisa de IDs garantidamente únicos

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

**Vantagens:**

- Entropia e segurança máximas
- Nenhuma dependência de tempo ou parâmetros do sistema
- Implementação mais simples

**Probabilidade de colisão:** Ao gerar 1 bilhão de UUIDs por segundo por 100 anos, a chance de colisão é de aproximadamente 0,00000006%.

### UUID v5 (Hash SHA-1)

O UUID v5 é o mesmo que o v3, mas usa SHA-1 em vez de MD5. Uma alternativa mais moderna e segura ao v3.

**Uso:**

- O mesmo que o v3, mas com melhor segurança
- Preferível ao v3 para novos projetos
- Geração de UUIDs a partir de URLs, nomes DNS, OID, X.500 DN

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

**Vantagens:**

- Determinístico
- SHA-1 é mais robusto que MD5
- Adequado para mapeamento entre sistemas

**Desvantagens:**

- SHA-1 também é considerado obsoleto (mas ainda mais seguro que MD5)
- Requer namespace e nome

### UUID v6 (Carimbo de Data/Hora Ordenado)

O UUID v6 é uma versão aprimorada do v1 com bits de tempo rearranjados para melhor indexação em DB. Projetado para resolver problemas de localidade em bancos de dados.

**Uso:**

- Chaves primárias de banco de dados com ordenação por tempo
- Sistemas que exigem ordenação cronológica e desempenho de DB
- Alternativa mais moderna ao v1

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

**Vantagens:**

- Melhor localidade de DB do que v1 (carimbo de data/hora em bits de ordem alta)
- Ordenação cronológica
- Compatível com o padrão UUID

**Desvantagens:**

- Menos usado que v1/v4
- Ainda contém informações de tempo (risco de segurança)

### UUID v7 (Carimbo de Data/Hora Unix)

O UUID v7 usa o carimbo de data/hora Unix (milissegundos desde 1970) + bits aleatórios. A versão mais recente de UUID com a melhor localidade de DB.

**Uso:**

- Chaves primárias de banco de dados modernas
- Sistemas que exigem desempenho + ordenação por tempo
- Substituição para v1/v6 em novos projetos

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

**Vantagens:**

- Melhor localidade de DB de todas as versões
- O carimbo de data/hora Unix é padrão
- Combina as vantagens de aleatoriedade e ordenação por tempo

**Desvantagens:**

- Especificação relativamente nova (RFC 4122bis)
- Menos suportado em sistemas legados

## Qual versão de UUID usar?

### Guia de decisão

**Precisa de segurança e aleatoriedade máximas?** → Use **UUID v4** (a escolha mais comum)

**Precisa de ordenação por tempo e desempenho de DB?** → Use **UUID v7** (moderno) ou **UUID v6** (padrão)

**Precisa de UUIDs reproduzíveis a partir de identificadores existentes?** → Use **UUID v5** (SHA-1) ou **UUID v3** (MD5, legado)

**Precisa de carimbo de data/hora e trilha de auditoria?** → Use **UUID v1** (legado, pior desempenho de DB)

### Bancos de dados

**Para novos projetos:** UUID v7 ou v4

- **v7** é ideal para ordenação por tempo + desempenho
- **v4** para aleatoriedade máxima sem informações de tempo

**Para sistemas legados:** UUID v1 ou v6

- **v6** tem melhor localidade de DB que v1
- **v1** é amplamente suportado

**Vantagens do UUID como chave primária:**

- **Unicidade global** – Você pode conectar dados de diferentes bancos de dados sem conflito
- **Segurança** – Ao contrário dos IDs sequenciais (1, 2, 3…), não é possível adivinhar os próximos valores
- **Sistemas distribuídos** – UUIDs podem ser gerados independentemente em vários servidores sem coordenação
- **Fusão de bancos de dados** – Nenhuma colisão ocorre ao mesclar dois bancos de dados

**Desvantagens:**

- Tamanho maior (16 bytes vs 4-8 bytes para inteiro)
- Indexação mais lenta em alguns bancos de dados (use v6/v7 para melhor desempenho)
- Menos legível para humanos

### API e serviços web

- **REST API** – Identificadores únicos para recursos
- **GraphQL** – Identificadores globais para nós
- **Webhooks** – Rastreamento de solicitações e respostas
- **Tokens** – IDs de sessão, tokens de atualização

### Arquivos e armazenamento

- **Nomes de arquivo** – Prevenção de colisões no upload
- **S3/Cloud Storage** – Caminhos de objeto únicos
- **Chaves de cache** – Identificadores em sistemas de cache

### Aplicações Frontend

- **Componentes React/Vue** – Chaves únicas para listas
- **IDs Temporários** – IDs antes de salvar no banco de dados
- **Armazenamento local** – Chaves para dados armazenados
- **Aplicações offline-first** – Geração de IDs sem conexão com o servidor

## Funções avançadas do gerador

### Geração de UUID com tempo personalizado

Para versões baseadas em tempo (v1, v6, v7), você pode selecionar qualquer carimbo de data/hora usando um seletor de data e hora. Isso é útil para:

**Testes:**

- Simulação de UUIDs criados no passado
- Teste de ordenação por tempo em bancos de dados
- Reprodução de UUIDs para depuração

**Migração de dados:**

- Geração de UUIDs com carimbos de data/hora históricos
- Preenchimento de dados com valores de carimbo de data/hora corretos
- Importação de dados de diferentes períodos de tempo

**Auditoria e conformidade:**

- Reconstrução de UUIDs de acordo com o tempo de criação do registro
- Geração retroativa de identificadores

**Exemplo de uso:**

1. Selecione a versão v1, v6 ou v7
2. Defina a data e hora usando o seletor de data e hora
3. Gere UUIDs com seu carimbo de data/hora personalizado

### UUIDs baseados em Hash (v3, v5)

Para UUIDs determinísticos, você pode usar as versões v3 (MD5) ou v5 (SHA-1):

**Como usar:**

1. Selecione o namespace de acordo com o tipo do seu identificador
2. Insira o nome/valor
3. Gere o UUID

**Exemplos:**

| Namespace | Nome (entrada) | Uso |
| --- | --- | --- |
| DNS | `example.com` | Conversão de nome de domínio para UUID |
| DNS | `google.com` | Cada site tem um UUID único |
| URL | `https://example.com/page` | Conversão de URL para UUID |
| URL | `https://api.example.com/users/123` | Endpoint de API como UUID |
| OID | `1.3.6.1.4.1.343` | Identificador de Objeto para UUID |
| X.500 | `CN=John Doe,O=Company` | Nome Distinto para UUID |

**Propriedades importantes:**

- ✅ **Determinístico**: Mesma entrada = sempre o mesmo UUID
- ✅ **Reproduzível**: Você pode recriar o UUID a qualquer momento
- ✅ **Consistente**: O mesmo UUID em diferentes sistemas
- ❌ **Não decodificável**: Não é possível obter o nome original a partir do UUID
- ℹ️ **Um UUID**: Para v3/v5, apenas um UUID é sempre gerado (mesma entrada = mesma saída)

**Uso prático:**

```
// Exemplo: Conversão de URL para UUID v5
Namespace: URL
Nome: https://example.com/api/users/123
Resultado: 886313e1-3b8a-5372-9b90-0c9aee199e5d

// Mesma entrada = sempre o mesmo UUID
Namespace: DNS
Nome: google.com
Resultado: sempre o mesmo UUID para google.com
```

## Como usar UUIDs com segurança?

### Segurança criptográfica

Nosso gerador usa `crypto.getRandomValues()`, que é um gerador de números aleatórios criptograficamente seguro. Ao contrário de `Math.random()`, que é previsível e inadequado para fins de segurança, `crypto.getRandomValues()` fornece entropia real adequada para:

- Geração de tokens de segurança
- IDs de sessão
- Chaves de API
- Aplicações criptográficas

### Comparação de versões de UUID

| Versão | Base | Colisão | Ordenação por tempo | Desempenho de DB | Uso |
| --- | --- | --- | --- | --- | --- |
| v1 | Carimbo de Data/Hora + MAC | Baixa | ✅ Sim | ❌ Pior | Legado, auditoria |
| v3 | Hash MD5 | Nenhuma (determinístico) | ❌ Não | ⚠️ Médio | Conversões (legado) |
| v4 | Aleatório | Extremamente baixa | ❌ Não | ⚠️ Médio | Uso geral |
| v5 | Hash SHA-1 | Nenhuma (determinístico) | ❌ Não | ⚠️ Médio | Conversões (recomendado) |
| v6 | Carimbo de Data/Hora Ordenado | Baixa | ✅ Sim | ✅ Melhor | DBs modernas com tempo |
| v7 | Carimbo de Data/Hora Unix | Baixa | ✅ Sim | ✅ Melhor | Novos projetos |

### UUID vs outros identificadores

| Tipo | Tamanho | Colisão | Ordenação por tempo | Uso |
| --- | --- | --- | --- | --- |
| ID de incremento automático | 4-8 bytes | Garantidamente único dentro da tabela | ❌ | Aplicações simples, DB local |
| UUID v4 | 16 bytes | Praticamente impossível | ❌ | Sistemas distribuídos, API |
| UUID v7 | 16 bytes | Praticamente impossível | ✅ | DBs modernas com desempenho |
| ULID | 16 bytes | Praticamente impossível | ✅ | UUID + ordenação lexicográfica |
| Snowflake ID | 8 bytes | Garantidamente único com configuração correta | ✅ | Twitter, sistemas distribuídos |
| NanoID | Configurável | Depende do comprimento | ❌ | IDs amigáveis para URL |

## Implementação em diferentes linguagens

### JavaScript/TypeScript

```
// UUID v4 - A maneira mais simples (navegadores modernos)
const uuid = crypto.randomUUID();

// UUID v4 - Implementação manual
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 - Recomendado para bancos de dados
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();
```

## Melhores Práticas

### Armazenamento de UUID em banco de dados

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

**Dica:** No MySQL, armazene UUIDs como `BINARY(16)` em vez de `CHAR(36)` para economizar espaço e indexação mais rápida.

### Validação de 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);
}
```

### Conversão de UUID

```
// Remoção de hífens
const compact = uuid.replace(/-/g, '');

// Adição de hífens de volta
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('-');
}
```

## Resolução de problemas (Troubleshooting)

### UUID v3/v5 não funciona

**Problema:** Nada é gerado após selecionar v3 ou v5

**Solução:**

1. ✅ Verifique se você **preencheu o campo “Nome”** - é obrigatório!
2. ✅ Selecione o namespace correto de acordo com o tipo da sua entrada
3. ✅ Exemplos de entradas válidas:
   - DNS: `example.com`, `google.com`
   - URL: `https://example.com/page`
   - Qualquer texto: `minha-aplicacao-v1`

**Dica:** Tente primeiro um valor simples como `teste` e o namespace DNS.

### UUIDs baseados em tempo (v1, v6, v7) têm um tempo estranho

**Problema:** O UUID gerado tem um carimbo de data/hora inesperado

**Solução:**

1. ✅ Verifique o seletor de data e hora - o tempo está configurado corretamente?
2. ✅ O seletor de data e hora usa seu fuso horário local
3. ✅ Deixe o seletor de data e hora vazio para o tempo atual

### O UUID não pode ser copiado

**Problema:** O botão “Copiar tudo” não funciona

**Solução:**

1. ✅ Verifique se você gerou UUIDs (não estão vazios)
2. ✅ Alguns navegadores exigem HTTPS para a API da área de transferência
3. ✅ Alternativamente, selecione o texto na caixa de texto e copie manualmente (Ctrl+C)

## Perguntas Frequentes (FAQ)

### Pode ocorrer colisão de UUID?

Teoricamente sim, mas a probabilidade é astronomicamente pequena. Ao gerar 1 bilhão de UUIDs v4 por segundo por 100 anos, a chance de colisão é de aproximadamente 0,00000006%. Na prática, uma colisão nunca acontecerá.

### O UUID é adequado como chave primária em um banco de dados?

Depende do caso de uso. O UUID é ideal para sistemas distribuídos e situações em que você precisa de unicidade global. Para aplicações simples com um único banco de dados, o incremento automático pode ser mais eficiente.

### Os UUIDs gerados por esta ferramenta são seguros?

Sim, usamos a Web Crypto API (\`crypto.getRandomValues()\`), que fornece valores aleatórios criptograficamente seguros. Tudo acontece localmente no seu navegador.

### Qual é a diferença entre as versões de UUID?

\- \*\*v1\*\*: Carimbo de data/hora + MAC/aleatório - ordenação cronológica, pior desempenho de DB - \*\*v3/v5\*\*: Baseado em hash - determinístico, para conversão de identificadores conhecidos - \*\*v4\*\*: Aleatório - mais seguro, mais usado - \*\*v6\*\*: Carimbo de data/hora rearranjado - melhor desempenho de DB que v1 - \*\*v7\*\*: Carimbo de data/hora Unix - melhor desempenho de DB + ordenação por tempo

### Qual versão de UUID devo usar?

Para a maioria dos casos, use \*\*v4\*\* (aleatório). Para bancos de dados com ordenação por tempo, use \*\*v7\*\* (moderno) ou \*\*v6\*\* (padrão). Para converter identificadores conhecidos (URL, DNS), use \*\*v5\*\* (SHA-1).

### Posso usar UUIDs para tokens e chaves de API?

UUID v4 é adequado para IDs de sessão e tokens semelhantes. Para chaves de API, considere usar strings aleatórias mais longas (por exemplo, valores de 256 bits) ou bibliotecas especializadas.

### Qual o tamanho dos UUIDs?

Um UUID tem 128 bits (16 bytes). No formato de string com hífens, ocupa 36 caracteres. Sem hífens, 32 caracteres hexadecimais.

## Alternativas ao UUID

### ULID (Identificador Universalmente Único Classificável Lexicograficamente)

- ID de 128 bits (o mesmo que UUID)
- Classificável lexicograficamente pelo tempo de criação
- Representação mais compacta (26 caracteres em vez de 36)
- Codificação base32 sem distinção entre maiúsculas e minúsculas

**Exemplo:** `01ARZ3NDEKTSV4RRFFQ69G5FAV`

### NanoID

- Tamanho menor que UUID (21 caracteres por padrão)
- Amigável para URL (sem caracteres especiais)
- Geração mais rápida
- Comprimento e alfabeto configuráveis

**Exemplo:** `V1StGXR8_Z5jdHi6B-myT`

### Snowflake ID (Twitter)

- ID de 64 bits (menor que UUID)
- Classificável por tempo
- Contém ID de worker e número de sequência
- Requer configuração centralizada

**Exemplo:** `1234567890123456789`

## Desempenho e otimização

### Velocidade de geração

Nosso gerador pode gerar:

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

### Dicas de desempenho

1. **Geração em lote** – Se precisar de muitos UUIDs, gere-os de uma vez em vez de um por um
2. **Armazenamento em DB** – Indexe as colunas UUID para buscas rápidas
3. **Compressão** – Armazene UUIDs em formato binário (16 bytes) em vez de string (36 bytes)
4. **Cache** – Em alguns casos, você pode pré-gerar e armazenar UUIDs em cache

## Para desenvolvedores

### Estrutura do UUID v4

```
xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
|        |    |    |    |
|        |    |    |    └─ 48 bits de dados aleatórios (node)
|        |    |    └────── 16 bits de dados aleatórios com variante (clock_seq)
|        |    └─────────── 12 bits de dados aleatórios + 4 bits de versão (time_hi_and_version)
|        └──────────────── 16 bits de dados aleatórios (time_mid)
└───────────────────────── 32 bits de dados aleatórios (time_low)
```

- Versão (4 bits): sempre `0100` (binário) = `4` (hex)
- Variante (2-3 bits): sempre `10` (binário) para RFC 4122

### Teste de UUID

```
// Teste Jest
describe('Gerador de UUID', () => {
  test('gera UUID v4 válido', () => {
    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('gera UUIDs únicos', () => {
    const uuid1 = generateUUIDv4();
    const uuid2 = generateUUIDv4();
    expect(uuid1).not.toBe(uuid2);
  });
});
```

## Aspectos de segurança

### O que não fazer com UUIDs

❌ **Não use UUID v1 para aplicações sensíveis** – Contém carimbo de data/hora, o que pode ser um risco de segurança

❌ **Não use `Math.random()` para gerar UUIDs** – Não é criptograficamente seguro

❌ **Não dependa de UUIDs para autorização** – UUIDs podem ser adivinhados (embora com probabilidade extremamente baixa)

❌ **Não armazene UUIDs em cookies sem criptografia** – Use cookies assinados ou JWT

### O que fazer

✅ **Use UUID v4 para a maioria dos casos** – Maior entropia e segurança

✅ **Combine UUIDs com outras medidas de segurança** – Para gerenciamento de sessão, use HTTPS, cookies HttpOnly e expiração curta

✅ **Valide UUIDs no servidor** – Sempre verifique o formato e a versão do UUID

✅ **Use fontes de aleatoriedade criptograficamente seguras** – `crypto.getRandomValues()` no navegador, `/dev/urandom` no Linux

## Curiosidades

- **Número de UUIDs v4 possíveis:** 2^122 ≈ 5.3 × 10^36 (340 undecilhões)
- **Colisão necessária:** Para uma chance de 50% de colisão, você deve gerar 2.71 × 10^18 UUIDs (2.71 quintilhões)
- **Tamanho de todos os UUIDs possíveis:** Se cada UUID fosse armazenado como 16 bytes, todo o espaço ocuparia 85 zettabytes (85 bilhões de terabytes)
- **Origem:** O UUID foi padronizado como parte do DCE (Distributed Computing Environment) em 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))
- 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))