Base64 vs hex, Base32, Base58 y Base85: comparativa

Tabla comparativa

Todas estas codificaciones convierten bytes arbitrarios en texto imprimible y vuelven atrás sin pérdidas. Se diferencian en cuántos caracteres usan, cuáles, y cuánto crece la salida.

El «tamaño de salida» es la longitud codificada como proporción de la longitud de entrada, para entradas grandes. Base64 necesita 4 caracteres por cada 3 bytes, Base32 8 por cada 5, Base85 5 por cada 4 y Base45 3 por cada 2. Base58 no tiene un tamaño de bloque fijo, así que su proporción es log(256) / log(58), alrededor de 1,366. Para las cifras exactas de una entrada concreta, la calculadora de tamaño las muestra todas a la vez.

La misma entrada en cada codificación

Esta es la cadena ASCII de 12 bytes Hello world! codificada de nueve formas. Doce bytes es múltiplo de 3 y de 4, así que Base64 y las variantes de Base85 no necesitan relleno.

Base64URL es idéntico a Base64 en este caso porque la salida no contiene + ni /. La diferencia solo aparece con ciertos bytes: fb ef be es ++++ en Base64 y ---- en Base64URL.

La biblioteca estándar de Python cubre casi toda la tabla. z85encode se añadió en Python 3.13:

import base64

data = b"Hello world!"
print(data.hex())                           # 48656c6c6f20776f726c6421
print(base64.b32encode(data).decode())      # JBSWY3DPEB3W64TMMQQQ====
print(base64.b64encode(data).decode())      # SGVsbG8gd29ybGQh
print(base64.a85encode(data).decode())      # 87cURD]j7BEbo80
print(base64.b85encode(data).decode())      # NM&qnZy<MXa%^NF
print(base64.z85encode(data).decode())      # nm=QNzY<mxA+]nf

Base58 no está en la biblioteca estándar, pero cabe en unas pocas líneas porque es una simple conversión de base de un entero grande:

B58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz"

def b58encode(data: bytes) -> str:
    n = int.from_bytes(data, "big")
    out = ""
    while n:
        n, r = divmod(n, 58)
        out = B58[r] + out
    zeros = len(data) - len(data.lstrip(b"\0"))
    return "1" * zeros + out

print(b58encode(b"Hello world!"))   # 2NEpo7TZRhna7vSvL
print(b58encode(b"\0\0\x01"))       # 112

Cada byte cero inicial se convierte en un 1 literal, porque un entero grande no tiene forma de recordar los ceros a la izquierda. Por eso todas las direcciones Bitcoin legacy con un byte de versión cero empiezan por 1.

Dónde se usa cada codificación

Hex

Hex gasta dos caracteres por byte, lo que la convierte en la opción más grande de esta lista y la más fácil de leer. Cada carácter corresponde exactamente a 4 bits, así que el byte en la posición n siempre ocupa los caracteres 2n y 2n+1. Por esa propiedad, los hashes, las sumas de comprobación y los volcados de depuración casi siempre están en hex. Los decodificadores aceptan tanto DEADBEEF como deadbeef. Convierte con Base64 a hex y hex a Base64.

Base32

Base32 usa solo letras mayúsculas y los dígitos del 2 al 7. Sobrevive a sistemas que no distinguen mayúsculas (nombres DNS, algunos sistemas de archivos, personas que teclean códigos en un móvil) y evita 0, 1 y 8, que se parecen a O, I y B. Las apps de autenticación guardan los secretos TOTP en Base32, y las direcciones onion v3 de Tor son 56 caracteres Base32 en minúsculas. RFC 4648 define además base32hex (0-9 A-V), que conserva el orden de los bytes originales. Prueba el codificador Base32.

Base58

Base58 nació con Bitcoin. Elimina 0, O, I y l (fáciles de confundir) y + y / (que rompen la selección con doble clic y las URLs). Las direcciones Bitcoin añaden encima un byte de versión y una suma de comprobación de 4 bytes, un formato llamado Base58Check. Los hashes CIDv0 de IPFS también son Base58, y como empiezan por los bytes multihash 12 20, siempre comienzan por Qm. Como toda la entrada se trata como un único número, el tiempo de conversión crece de forma cuadrática con la longitud, así que Base58 se usa para valores cortos, como claves y hashes. Prueba el codificador Base58.

Ascii85, Z85 y el Base85 de git

La familia Base85 empaqueta 4 bytes en 5 caracteres, la más densa de las codificaciones con amplio soporte. El problema es el alfabeto: 85 caracteres imprimibles implican comillas, barras invertidas, <, > o &, según la variante.

• Ascii85 (Adobe) usa de ! a u, envuelve la salida entre <~ y ~> y escribe cuatro bytes cero como una sola z. Lo usan PostScript y PDF (el filtro ASCII85Decode).
• Z85 (ZeroMQ) elige caracteres seguros dentro de literales de cadena de C y JSON, sin comillas ni barra invertida. Exige que la longitud de entrada sea múltiplo de 4. Una clave CURVE de 32 bytes ocupa 40 caracteres.
• Base85 de RFC 1924 fue una propuesta del Día de los Inocentes de abril para direcciones IPv6. Su alfabeto sigue vivo en los parches binarios de git y en b85encode de Python.

La herramienta Base85 maneja las tres; Z85 tiene su propia página.

Base45

Base45 existe para los códigos QR. El modo alfanumérico de un código QR guarda exactamente 45 caracteres (dígitos, letras mayúsculas, espacio y $%*+-./:) a 5,5 bits cada uno, frente a 8 bits por carácter en modo byte. Base45 convierte 2 bytes en 3 de esos caracteres, lo que cuesta alrededor de un 3 % dentro del código QR. El texto Base64 tiene que usar el modo byte y cuesta un 33 %. El Certificado COVID Digital de la UE usaba Base45 justo por eso. Prueba el codificador Base45.

Cómo elegir

Elige la codificación que espera el receptor. Una biblioteca JWT quiere Base64URL, una app de autenticación quiere Base32 y un monedero Bitcoin quiere Base58Check. Cuando controlas ambos extremos, valen estas reglas prácticas:

• Bytes dentro de JSON, XML, correo o cuerpos HTTP: Base64. Todos los lenguajes tienen una implementación integrada y rápida, y un 33 % más de tamaño es aceptable.
• Dentro de una URL, una cookie o un nombre de archivo: Base64URL sin relleno.
• Si las personas van a leer, teclear o comparar el valor: hex para hashes cortos, Base32 cuando se puedan perder las mayúsculas, Base58 cuando deba parecer compacto y sin caracteres que se confundan.
• Cada byte cuenta y controlas el decodificador: Z85 o Ascii85.
• Códigos QR: Base45.

El compromiso es siempre el mismo: un alfabeto mayor da una salida más corta y más caracteres que habrá que escapar en algún sitio. Para entender por qué Base64 crece un tercio, consulta El aumento de tamaño de Base64. Para la variante URL-safe, consulta Base64 vs Base64URL.

Preguntas frecuentes