Herramientas mencionadas en este artículo
Abre la herramienta en el navegador mientras lees y prueba el flujo al instante.
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 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=.
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.
