El problema que resuelve Base64

Los datos binarios (imágenes, audio, archivos ejecutables) son un flujo de bytes con valores de 0 a 255. Muchos protocolos basados en texto (correo electrónico, cabeceras HTTP, JSON, XML) se diseñaron para manejar solo un subconjunto de esos valores: los caracteres ASCII imprimibles. Cuando los datos binarios pasan por estos sistemas sin codificar, los bytes que quedan fuera del rango imprimible se corrompen o se interpretan mal.

Base64, Base58 y Base32 explicados: cuándo y cómo usar cada codificación

Base64 lo resuelve convirtiendo datos binarios arbitrarios en una cadena que contiene solo caracteres ASCII seguros e imprimibles. La cadena resultante puede pasar por cualquier sistema basado en texto sin corromperse.


Cómo funciona Base64 por dentro

Base64 usa un alfabeto de 64 caracteres: A-Z (26), a-z (26), 0-9 (10), + y /, es decir, exactamente 64 caracteres, representables con 6 bits (2⁶ = 64).

El algoritmo procesa la entrada de 3 en 3 bytes (24 bits), los divide en cuatro grupos de 6 bits y asigna cada grupo a un carácter del alfabeto:

Bytes de entrada:  M         a         n
Binario:   01001101  01100001  01101110
                    ↓ reagrupar en 4 × 6 bits ↓
Grupos:    010011  010110  000101  101110
Índice:      19      22       5      46
Carácter:     T      W       F       u
Salida:   T W F u

Relleno (padding)

Cuando la longitud de la entrada no es divisible por 3, se añaden caracteres de relleno (=) para que la salida sea un múltiplo de 4 caracteres:

  • 1 byte restante → 2 caracteres Base64 + ==
  • 2 bytes restantes → 3 caracteres Base64 + =
  • 0 bytes restantes → no hace falta relleno
"Ma"   (2 bytes) → "TWE="
"M"    (1 byte)  → "TQ=="
"Man"  (3 bytes) → "TWFu" (sin relleno)

El sobrecoste del 33 %

Como 3 bytes se convierten en 4 caracteres, Base64 produce siempre una salida de aproximadamente 4/3 = 133 % del tamaño de la entrada. Para una imagen de 100 KB, la representación en Base64 es de unos 133 KB.

Este sobrecoste importa al incrustar imágenes en HTML como data URI o al transmitirlas en peticiones de API. Para archivos grandes es mejor referenciarlos por URL que incrustarlos en Base64.


Variantes de Base64

Variante Diferencia en el alfabeto Relleno Uso habitual
Base64 estándar + y / = Correo (MIME), uso general
Base64Url - y _ en lugar de + y / Opcional URL, JWT, cookies
Base64 (MIME) Igual que el estándar, con saltos de línea cada 76 caracteres = Adjuntos de correo

Por qué existe Base64Url

El Base64 estándar usa + y /, que tienen significado especial en las URL (+ = espacio, / = separador de ruta). Base64Url los sustituye por - y _, y produce cadenas seguras para usar directamente en URL, cookies y cabeceras HTTP, sin codificación porcentual.

Los JWT usan Base64Url por este motivo: cada uno de los tres segmentos (cabecera, payload y firma) está codificado en Base64Url, y el token entero se puede usar sin problemas en una cabecera Authorization o en un parámetro de consulta de una URL.

// Base64 estándar — puede contener + / =
btoa('binary data with /')   // "YmluYXJ5IGRhdGEgd2l0aCAvCg=="

// Base64Url — seguro para URL
function toBase64Url(str) {
  return btoa(str)
    .replace(/\+/g, '-')
    .replace(/\//g, '_')
    .replace(/=+$/, '');  // opcional: quitar el relleno
}

Codificación y decodificación en lenguajes habituales

JavaScript (navegador y Node.js)

// Codificar una cadena en Base64
const encoded = btoa('Hello, World!');
console.log(encoded); // "SGVsbG8sIFdvcmxkIQ=="

// Decodificar
const decoded = atob('SGVsbG8sIFdvcmxkIQ==');
console.log(decoded); // "Hello, World!"

// Para datos binarios (por ejemplo, imágenes) en Node.js
const buffer = Buffer.from(imageBytes);
const base64 = buffer.toString('base64');
const back = Buffer.from(base64, 'base64');

// Navegador: codificar datos binarios desde un ArrayBuffer
async function arrayBufferToBase64(buffer) {
  const bytes = new Uint8Array(buffer);
  let binary = '';
  bytes.forEach(b => (binary += String.fromCharCode(b)));
  return btoa(binary);
}

Limitación de btoa: solo admite cadenas Latin-1. Para Unicode multibyte (emoji, caracteres CJK), primero hay que codificar a bytes UTF-8:

function encodeUnicode(str) {
  return btoa(
    encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
      (_, p1) => String.fromCharCode(parseInt(p1, 16)))
  );
}

Python

import base64

# Codificar
encoded = base64.b64encode(b'Hello, World!')
print(encoded)  # b'SGVsbG8sIFdvcmxkIQ=='

# Decodificar
decoded = base64.b64decode(b'SGVsbG8sIFdvcmxkIQ==')
print(decoded)  # b'Hello, World!'

# Variante segura para URL
url_encoded = base64.urlsafe_b64encode(b'binary+data/here')
print(url_encoded)  # b'YmluYXJ5K2RhdGEvaGVyZQ=='  (+ y / sustituidos)

Go

import (
    "encoding/base64"
    "fmt"
)

// Codificación estándar
encoded := base64.StdEncoding.EncodeToString([]byte("Hello, World!"))
fmt.Println(encoded) // SGVsbG8sIFdvcmxkIQ==

// Codificación segura para URL (sin relleno)
urlEncoded := base64.RawURLEncoding.EncodeToString([]byte("Hello, World!"))
fmt.Println(urlEncoded) // SGVsbG8sIFdvcmxkIQ

// Decodificar
decoded, err := base64.StdEncoding.DecodeString(encoded)

Base58: la elección de Bitcoin

Base58 usa 58 caracteres: todos los alfanuméricos menos los visualmente ambiguos: 0 (cero), O (o mayúscula), I (i mayúscula) y l (ele minúscula). Tampoco tiene +, / ni =.

El objetivo: producir cadenas que las personas puedan leer, teclear y copiar sin confusión, algo especialmente importante para las direcciones de criptomonedas y las copias de seguridad de monederos en papel.

Codificación Caracteres Relleno ¿Legible para personas? Sobrecoste de tamaño
Base64 64 = Confuso ~33 %
Base64Url 64 opcional Confuso en texto ~33 %
Base58 58 Ninguno Sí ~38 %
Base58Check 58+suma de comprobación Ninguno Sí ~38 % + suma de comprobación

Base58Check (usado por Bitcoin) añade una suma de comprobación de 4 bytes derivada de SHA-256(SHA-256(payload)) antes de la codificación Base58. Esto permite detectar errores de transcripción.


Base32: el formato de clave de API seguro para personas

Base32 usa solo 32 caracteres: A-Z y 2-7. Como emplea solo letras mayúsculas y un conjunto restringido de dígitos, resulta especialmente útil para:

  • TOTP (contraseñas de un solo uso basadas en el tiempo): los secretos de Google Authenticator están codificados en Base32.
  • Sistemas que no distinguen mayúsculas de minúsculas: sistemas de archivos o identificadores en los que no se puede conservar la capitalización.
  • Entrada oral o manual: menos caracteres ambiguos que Base64.

La contrapartida: Base32 es menos compacto. Cada 5 bytes se convierten en 8 caracteres (60 % de sobrecoste frente al 33 % de Base64).

import base64

# Codificación Base32 de un secreto TOTP
secret = b'\x87\x65\x43\x21'
encoded = base64.b32encode(secret)
print(encoded)  # b'Q5SUEG=='

# Decodificar
decoded = base64.b32decode(b'Q5SUEG==')

Cuándo usar cada codificación

Caso de uso Codificación recomendada
Adjuntos de correo (MIME) Base64 estándar
Tokens JWT Base64Url
Parámetros de consulta de URL Base64Url
Data URI en HTML/CSS Base64 estándar
Direcciones de Bitcoin y criptomonedas Base58Check
Secretos TOTP (Google Authenticator) Base32
Claves de API pensadas para copiarse a mano Base58 o Base32
Sumas de comprobación de archivos en URL Base64Url

Novedades de noviembre de 2026

  • Se añadieron Base62, Ascii85, Base45 y Base32hex (Base45 es el RFC 9285, pensado para códigos QR; Base32hex es el RFC 4648).
  • El modo Base64URL codifica y decodifica la forma con - y _ de los JWT, sin relleno =.

Pruébalo en la herramienta

Preguntas frecuentes

¿Ofrece Base64 alguna seguridad?

No. Base64 es una codificación, no un cifrado. Cualquiera que reciba una cadena Base64 puede decodificarla sin esfuerzo. No uses nunca Base64 como forma de “ocultar” datos sensibles.

¿Por qué los JWT usan Base64Url sin relleno?

Los JWT omiten los caracteres de relleno = para que el token sea aún más seguro para URL (el = de relleno requiere codificación porcentual en las URL). El extremo receptor deduce la longitud del relleno a partir de la longitud de la cadena. La mayoría de las bibliotecas de JWT lo gestionan automáticamente.

¿Puedo codificar un archivo entero en Base64?

Sí, pero ten en cuenta el sobrecoste. Un archivo binario de 1 MB se convierte en aproximadamente 1,37 MB en Base64. Para archivos grandes, suele ser mejor subir el archivo directamente y referenciarlo por URL. Incrustar en Base64 es práctico para recursos pequeños como favicons (unos pocos KB) incrustados en HTML o CSS.

¿Qué significa data:image/png;base64,...?

Es un data URI: una forma de incrustar el contenido de un archivo directamente en un archivo HTML o CSS. El navegador decodifica el Base64 y usa el resultado como si hubiera descargado la imagen desde una URL. Los iconos pequeños (de menos de ~1 KB) son buenos candidatos para esta técnica; las imágenes más grandes deberían seguir siendo archivos independientes.

¿Existe un Base128 o un Base256?

Codificar con bases más altas es posible, pero no resulta útil: una vez que se superan los 94 caracteres ASCII imprimibles (Base94), añadir más caracteres introduce ambigüedad con los caracteres de control o exige codificaciones multibyte, lo que anula el propósito. Base64 es el punto óptimo entre compacidad y universalidad.