Generador de Hash - MD5, SHA-1, SHA-256, SHA-512
Genera hashes criptográficos en línea con soporte para MD5, SHA-1, SHA-256, SHA-512. Hashea texto y archivos, verifica la integridad y crea firmas HMAC, todo de...

Genera UUID (v1, v4) y GUID criptográficamente seguros al instante con nuestra herramienta en línea gratuita. Generación masiva (1-1000), múltiples formatos de salida (JSON, SQL, CSV), validación de UUID y analizador. Perfecto para desarrolladores, administradores de bases de datos y desarrollo de API.
Genera UUID v4 con la Web Crypto API (crypto.randomUUID() y crypto.getRandomValues()) para obtener una generación de números aleatorios criptográficamente segura. Cada UUID v4 aporta 122 bits de verdadera aleatoriedad (2^122 = 5,3 × 10^36 valores posibles), obtenidos del pool de entropía de tu sistema operativo, lo que garantiza que la probabilidad de colisión sea efectivamente cero incluso a gran escala. A diferencia de los generadores de números pseudoaleatorios (PRNG) basados en Math.random(), la Crypto API ofrece valores impredecibles y no reproducibles, adecuados para aplicaciones sensibles a la seguridad, como tokens de sesión, claves de API, tokens de autenticación y enlaces de restablecimiento de contraseña. Todas las fuentes de aleatoriedad cumplen con NIST SP 800-90A para aplicaciones criptográficas. La probabilidad de colisión al generar 1000 millones de UUID por segundo de forma continua durante 85 años es inferior al 50%, algo prácticamente imposible en escenarios del mundo real.
Genera de 1 a 100 UUID al instante con vista previa en tiempo real y latencia cero. Perfecto para poblar bases de datos, generar fixtures, pruebas de carga y flujos de trabajo de desarrollo. Nuestra generación masiva admite escenarios de desarrollo habituales: crea 10 UUID para fixtures de usuarios, 50 para pruebas de catálogo de productos o 100 para evaluaciones de rendimiento. Toda la generación ocurre íntegramente en el lado del cliente con JavaScript: sin idas y vueltas al servidor, sin límites de velocidad de API y sin retrasos de red. Genera miles de UUID en milisegundos sin salir de tu navegador. Para necesidades masivas extremas (más de 1000), descarga la herramienta y ejecútala sin conexión. El generador mantiene un rendimiento constante independientemente de la cantidad: genera 100 UUID tan rápido como 1. Ideal para pipelines de CI/CD, migraciones de bases de datos y frameworks de pruebas automatizadas.
Exporta UUID en 8 salidas con formato profesional, listas para integrarlas directamente en tu código. El formato Array JSON (["uuid1", "uuid2"]) para respuestas de API REST, archivos de configuración e intercambio de datos. Array de JavaScript (const uuids = […]) para React, Node.js y frameworks de frontend. Lista de Python (uuids = […]) para Django, Flask y scripts de procesamiento de datos. Sentencias INSERT de SQL para PostgreSQL, MySQL y SQL Server con el escape correcto de comillas simples. Formato CSV con fila de encabezado para Excel, Google Sheets y análisis de datos. Array de C# (string[] uuids = {…}) para .NET, ASP.NET y Unity. Array de Java (String[] uuids = {…}) para Spring Boot, Android y aplicaciones empresariales. Lista simple (uno por línea) para scripts de shell, procesamiento de texto y compatibilidad universal. Cada formato incluye la sintaxis, la indentación y el escape correctos para código listo para producción.
Personaliza el formato de los UUID para que coincida con la guía de estilo y los requisitos técnicos de tu proyecto. El formato estándar (8-4-4-4-12 con guiones) sigue la especificación RFC 4122 y funciona en todas partes. Sin guiones (32 caracteres hexadecimales continuos) reduce la longitud de la cadena un 11% para URL compactas, nombres de archivo y almacenamiento en bases de datos (usa BINARY(16) para un rendimiento óptimo en MySQL). Llaves {uuid} para el formato GUID de Microsoft, la programación COM y el Registro de Windows. Corchetes [uuid] para arrays de PowerShell y notación personalizada. Paréntesis (uuid) para listas VALUES de SQL y otros envoltorios. Control de mayúsculas/minúsculas (MAYÚSCULAS vs minúsculas) para mantener la coherencia: minúsculas para las convenciones de Unix/Linux y las URL web, mayúsculas para las convenciones de Windows y sistemas heredados. Combina formatos y mayúsculas/minúsculas para generar UUID perfectamente formateados para tu caso de uso específico, los requisitos de tu framework y tus estándares de codificación.
Valida y analiza cualquier cadena UUID con una comprobación exhaustiva del cumplimiento de RFC 4122. Pega UUID de registros, bases de datos, respuestas de API o archivos de configuración para verificar al instante su validez y extraer metadatos. El validador identifica la versión del UUID (v1-v5) examinando los bits de versión, determina la variante (RFC 4122, compatibilidad con versiones anteriores de NCS, GUID de Microsoft, reservada), detecta el formato (estándar con guiones, compacto sin guiones, con envoltorio de llaves/corchetes) y marca los UUID Nil (todos ceros). La validación acepta entradas flexibles: formato estándar con guiones, formato compacto sin guiones, formatos con envoltorio ({uuid}, [uuid], (uuid)), mayúsculas y minúsculas mezcladas y espacios en blanco adicionales (recortados automáticamente). Perfecto para depurar, verificar la integridad de bases de datos, validar cargas útiles de API y solucionar problemas relacionados con UUID en sistemas distribuidos.
Genera UUID v1 (basado en marca de tiempo) para aplicaciones que requieren orden temporal e identificadores ordenables por tiempo. El UUID v1 codifica la marca de tiempo de generación (intervalos de 100 nanosegundos desde el 15 de octubre de 1582), la dirección MAC o un identificador de nodo aleatorio, y la secuencia de reloj para garantizar la unicidad. Entre las ventajas están: ordenación cronológica natural en bases de datos (útil para paginación y consultas basadas en el tiempo), posibilidad de extraer la marca de tiempo integrada para depuración y auditoría, y unicidad garantizada en sistemas distribuidos sin coordinación. Casos de uso: registro de eventos (mantener el orden de inserción), claves primarias de bases de datos distribuidas (CouchDB y Cassandra prefieren UUID ordenados por marca de tiempo), pistas de auditoría (extraer la hora de creación del ID) y migración desde ID secuenciales manteniendo el orden. Nota: los UUID v1 pueden exponer la dirección MAC; para aplicaciones sensibles a la privacidad, usa un identificador de nodo aleatorio o prefiere el UUID v4.
Toda la generación, validación y formateo de UUID ocurre íntegramente en tu navegador con JavaScript: comunicación cero con el servidor, sin transmisión de datos y privacidad total. Tus UUID nunca salen de tu dispositivo ni tocan nuestros servidores. No recopilamos, almacenamos, registramos ni transmitimos ningún UUID generado. Sin cookies, sin seguimiento de sesión, sin analíticas sobre los valores generados y sin llamadas a API de terceros. La herramienta usa la Web Crypto API (crypto.randomUUID() y crypto.getRandomValues()), que obtiene la aleatoriedad del pool de entropía seguro de tu sistema operativo (/dev/urandom en Linux/Mac, CryptGenRandom en Windows). Para máxima seguridad, descarga esta página y ejecútala sin conexión: todas las funciones funcionan sin conexión a internet. Consulta el código fuente de la página para verificarlo: sin llamadas a API externas, sin envíos de formularios, sin peticiones XHR. Perfecto para generar claves de API de producción, tokens de autenticación e identificadores sensibles a la seguridad en redes aisladas.
Los UUID son excelentes claves primarias para bases de datos distribuidas, arquitecturas de microservicios y sistemas que requieren generación de datos sin conexión. A diferencia de los enteros con autoincremento, los UUID se pueden generar de forma independiente en cualquier cliente o servicio sin coordinación con la base de datos, lo que permite una generación de ID verdaderamente distribuida. Esto elimina las idas y vueltas a la base de datos durante las operaciones INSERT, reduce la contención de bloqueos y permite aplicaciones móviles offline-first que se sincronizan más tarde. Almacena los UUID de forma eficiente: tipo UUID nativo de PostgreSQL (16 bytes), BINARY(16) en MySQL con la función UUID_TO_BIN(), tipo UNIQUEIDENTIFIER de SQL Server y la alternativa ObjectId de MongoDB. Para un rendimiento óptimo en las consultas, crea índices en las columnas UUID y usa CLUSTER (PostgreSQL) o índices de cobertura (MySQL). El UUID v1 proporciona un orden temporal natural (beneficioso para consultas por rango), mientras que el v4 ofrece una mejor distribución de escrituras entre páginas de índice. Compromisos: mayor almacenamiento (16 bytes frente a 4-8 bytes de los enteros), uniones ligeramente más lentas, pero enormes beneficios de escalabilidad para sistemas distribuidos.
Genera identificadores únicos para API REST, tokens de autenticación, claves de API, identificadores de sesión y parámetros de estado de OAuth. Las claves de API basadas en UUID aportan 122 bits de entropía, lo que las hace prácticamente imposibles de adivinar (a diferencia de los ID secuenciales, vulnerables a ataques de enumeración). Casos de uso: Tokens de sesión: genera UUID v4 para las sesiones de usuario sin patrones predecibles; Claves de API: combina UUID con una firma HMAC para una autenticación de API segura; ID de solicitud: rastrea solicitudes entre microservicios distribuidos usando cabeceras X-Request-ID; Estado de OAuth: la protección CSRF de los flujos OAuth requiere valores de estado impredecibles; Secretos de webhook: genera secretos únicos para la verificación de firmas de webhook; Tokens de restablecimiento de contraseña: tokens de un solo uso y tiempo limitado usando UUID v1 (incluye marca de tiempo). Usa siempre UUID v4 para tokens sensibles a la seguridad. Evita exponer UUID en las URL cuando sea posible (usa ID cortos o slugs para URL públicas), ya que los UUID perjudican el SEO y no son fáciles de usar.
Los nombres de archivo basados en UUID garantizan la unicidad de los archivos subidos, evitando colisiones de nombres en sistemas multiusuario, almacenamiento en la nube y CDN. Cuando los usuarios suben avatar.jpg, profile.png o document.pdf, genera nombres de archivo basados en UUID para evitar sobrescrituras: 550e8400-e29b-41d4-a716-446655440000.jpg para las subidas de usuarios, cache/550e8400e29b41d4a716446655440000 para archivos de caché temporales (los guiones son opcionales), thumbnails/550e8400-e29b-41d4-a716-446655440000_200x200.jpg para variantes de imágenes. Ventajas: sin condiciones de carrera durante las subidas simultáneas, seguro (los atacantes no pueden adivinar los nombres de archivo para enumerar archivos), independiente del sistema de archivos (funciona en Windows, Linux, macOS, S3, Azure Blob, GCS) y longitud constante para optimizar el almacenamiento. Buenas prácticas: guarda el nombre de archivo original en los metadatos de la base de datos (para las descargas), usa minúsculas para mantener la coherencia de las URL y organiza en subdirectorios (los 2-4 primeros caracteres del UUID) para evitar los límites de tamaño de directorio (550e/8400/…).
Los ID de correlación basados en UUID permiten el rastreo de solicitudes de extremo a extremo en microservicios distribuidos, contenedores y funciones serverless. Genera un UUID v4 en la puerta de enlace de API o el balanceador de carga, propágalo mediante las cabeceras X-Correlation-ID o X-Request-ID y regístralo en cada servicio para el rastreo distribuido. Arquitectura: API Gateway genera el UUID de correlación → Servicio de autenticación registra con el UUID → Servicio de lógica de negocio registra con el UUID → Servicio de base de datos registra con el UUID → Cola de mensajes incluye el UUID en los metadatos del mensaje → Workers asíncronos registran con el UUID. Esto crea una línea temporal completa de la solicitud en todos los servicios. Integración con la observabilidad: Datadog/New Relic (agrupación automática por ID de correlación), ELK Stack (filtrar registros por el campo correlation_id), Jaeger/Zipkin (ID de traza) y CloudWatch Logs (filterPattern con UUID). Ventajas: depurar problemas de producción en todos los servicios, medir la latencia de extremo a extremo, identificar fallos en cascada y auditar el cumplimiento de los flujos de datos de GDPR/HIPAA.
Genera fixtures de datos de prueba realistas mediante la generación masiva de UUID para pruebas automatizadas, entornos de staging y pruebas de carga. Crea conjuntos de datos de prueba coherentes: Fixtures de usuarios: genera 50 UUID v4 para ID de usuario en pruebas de Jest/Mocha; Catálogo de productos: genera 100 UUID para poblar la base de datos de productos de comercio electrónico; ID de transacciones: genera 1000 UUID para probar transacciones financieras; Registro de eventos: genera UUID v1 ordenados temporalmente para probar flujos de eventos. Los formatos de exportación se integran directamente con frameworks de pruebas: JSON para pruebas de contrato de API REST (Pact, WireMock), INSERT de SQL para cargar fixtures en bases de datos (migraciones de Flyway, Liquibase), arrays de JavaScript para fixtures de Jest/Mocha/Cypress y listas de Python para fixtures de pytest y patrones Factory de Django. Para pruebas reproducibles, combínalos con faker.js o bibliotecas de patrón Factory. Genera una vez, confirma en el repositorio como fixtures de prueba, garantizando datos de prueba coherentes en el pipeline de CI/CD, las máquinas de los desarrolladores y los entornos de staging.
Los ID de evento basados en UUID permiten un procesamiento de eventos idempotente en arquitecturas orientadas a eventos, sistemas CQRS y colas de mensajes (RabbitMQ, Kafka, SQS). Cada evento de dominio recibe un identificador UUID v4 único, que se almacena en el registro de eventos y se propaga a través de los metadatos del mensaje. Arquitectura: Comando genera el UUID → Evento almacena el UUID en el campo event_id → Mensaje incluye el UUID en la cabecera del mensaje → Consumidor comprueba el UUID para detectar duplicados → Tabla de idempotencia almacena el UUID procesado para evitar la repetición. Esto garantiza un procesamiento exactly-once incluso con semánticas de entrega at-least-once. Casos de uso: Claves primarias de un event store (EventStoreDB, Marten), Claves de mensaje de Kafka (garantizar la distribución entre particiones), ID de deduplicación de mensajes de SQS (las colas FIFO requieren ID únicos), ID de comandos CQRS (rastrear comandos hasta los eventos resultantes) y ID de transacciones Saga (coordinar transacciones distribuidas). El UUID v1 proporciona un orden temporal útil para la repetición de eventos y la depuración con viaje en el tiempo.
// Modern browsers (ES2022+) - Recommended
const uuid = crypto.randomUUID();
// Node.js (v14.17.0+)
import { randomUUID } from 'crypto';
const uuid = randomUUID();
// Fallback for older browsers
function generateUUID() {
return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
const r = Math.random() * 16 | 0;
const v = c === 'x' ? r : (r & 0x3 | 0x8);
return v.toString(16);
});
}
// UUID validation regex
const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
import uuid
# UUID v4 (random)
uuid_v4 = uuid.uuid4()
print(str(uuid_v4)) # '550e8400-e29b-41d4-a716-446655440000'
# UUID v1 (timestamp-based)
uuid_v1 = uuid.uuid1()
# UUID v5 (namespace + name)
namespace = uuid.NAMESPACE_DNS
uuid_v5 = uuid.uuid5(namespace, 'example.com')
# Validation
def is_valid_uuid(uuid_string):
try:
uuid.UUID(uuid_string)
return True
except ValueError:
return False
-- PostgreSQL (native UUID support)
CREATE TABLE users (
id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
email VARCHAR(255) NOT NULL
);
-- MySQL 8.0+ (BINARY storage)
CREATE TABLE users (
id BINARY(16) PRIMARY KEY DEFAULT (UUID_TO_BIN(UUID())),
email VARCHAR(255) NOT NULL
);
-- SQL Server
CREATE TABLE users (
id UNIQUEIDENTIFIER PRIMARY KEY DEFAULT NEWID(),
email NVARCHAR(255) NOT NULL
);
-- SQLite (TEXT storage)
CREATE TABLE users (
id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(16)))),
email TEXT NOT NULL
);
Optimización del almacenamiento: almacena los UUID como BINARY(16), no como VARCHAR(36), para ahorrar un 55% de espacio. El tipo UUID de PostgreSQL usa 16 bytes. MySQL: usa las funciones UUID_TO_BIN() y BIN_TO_UUID(). Indexación: los UUID crean una distribución aleatoria en los índices, lo que reduce el rendimiento de inserción frente a los ID secuenciales. Usa UUID v1 para una mejor localidad del árbol B. PostgreSQL: usa el comando CLUSTER para el orden físico. Generación masiva: genera los UUID por lotes durante la inicialización de la aplicación, no en cada solicitud. Guarda 1000 UUID en caché en un pool de memoria. Rendimiento de comparación: la comparación de UUID binarios es más rápida que la de cadenas. Convierte siempre a binario para las uniones y las cláusulas WHERE.
Gestiona múltiples programas de afiliados y mejora el rendimiento de tus socios afiliados con Post Affiliate Pro.
Genera hashes criptográficos en línea con soporte para MD5, SHA-1, SHA-256, SHA-512. Hashea texto y archivos, verifica la integridad y crea firmas HMAC, todo de...
Herramienta gratuita de conversión bidireccional entre CSV y JSON. Convierte CSV a JSON o JSON a CSV con detección automática de delimitadores, vista previa y m...
Herramienta gratuita de codificador y decodificador de URL en línea. Codifica y decodifica URLs, cadenas de consulta y componentes de URL al instante. Perfecta ...
Consentimiento de Cookies
Usamos cookies para mejorar tu experiencia de navegación y analizar nuestro tráfico. See our privacy policy.