Probablemente hayas visto cadenas Base64 dispersas por tu base de código — en tokens JWT, etiquetas HTML <img>, cabeceras HTTP Authorization, o cargas JSON que llevan datos de archivos. Parecen un galimatías: SGVsbG8sIFdvcmxkIQ==. Pero hay una razón sencilla por la que existen, y una vez que la entiendes, Base64 deja de ser misterioso y se convierte en una herramienta genuinamente útil en tu caja de herramientas.

Qué es realmente Base64

Base64 es un esquema de codificación de binario a texto. Eso es todo. Toma datos binarios arbitrarios — bytes que podrían incluir caracteres nulos, códigos de control, o cualquier valor de 0 a 255 — y los representa usando solo 64 caracteres ASCII imprimables. El resultado es una cadena que puede viajar de forma segura por cualquier canal basado en texto sin ser corrompida o malinterpretada.

La especificación formal se encuentra en RFC 4648, publicado por el IETF. Define tanto Base64 estándar como la variante segura para URL. Vale la pena marcar si alguna vez necesitas resolver una discusión sobre reglas de relleno o elecciones de alfabeto.

El alfabeto Base64

El alfabeto de 64 caracteres consta de: mayúsculas A–Z (26 caracteres), minúsculas a–z (26 caracteres), dígitos 0–9 (10 caracteres), y dos símbolos: + y /. Eso te da exactamente 64 caracteres — de ahí el nombre. El signo = se usa como carácter de relleno al final cuando la longitud de la entrada no es un múltiplo de 3.

text
ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/

Cada carácter codifica exactamente 6 bits de datos (2^6 = 64 valores posibles). Este es el mecanismo central detrás de la codificación — y la razón de ese ~33% de sobrecarga de tamaño.

Cómo funciona la codificación

El algoritmo trabaja en bloques de 3 bytes → 4 caracteres Base64. Tres bytes = 24 bits. Divide esos 24 bits en cuatro grupos de 6 bits, y cada grupo se mapea a un carácter en el alfabeto Base64.

text
Input:  "Man"
Bytes:  M=77 (01001101)  a=97 (01100001)  n=110 (01101110)
Bits:   010011 010110 000101 101110
Index:  19     22     5      46
Output: T      W      F      u     →  "TWFu"

Cuando la entrada no es divisible por 3, el relleno entra en juego. Dos bytes restantes se convierten en tres caracteres Base64 más un =. Un byte restante se convierte en dos caracteres Base64 más ==. El relleno simplemente le indica al decodificador cuántos bytes están realmente presentes al final — no es parte de los datos en sí.

La sobrecarga de tamaño: cada 3 bytes de entrada se convierten en 4 caracteres de salida. Eso es un aumento de tamaño del 33%. Para cadenas pequeñas es insignificante. Para archivos binarios grandes — una imagen de 10 MB se convierte en aproximadamente 13,3 MB de Base64 — la sobrecarga importa y deberías pensar dos veces antes de incrustar directamente.

Codificación y decodificación en JavaScript

Los navegadores exponen btoa() y atob() como globales. Son simples pero tienen un problema: solo manejan caracteres Latin-1 (valores de bytes 0–255). Pasa una cadena Unicode multibyte directamente y obtendrás un InvalidCharacterError.

js
// Basic browser encoding/decoding
const encoded = btoa('Hello, World!');  // "SGVsbG8sIFdvcmxkIQ=="
const decoded = atob('SGVsbG8sIFdvcmxkIQ==');  // "Hello, World!"

// Safe Unicode version — encode to UTF-8 first
function encodeUnicode(str) {
  return btoa(
    encodeURIComponent(str).replace(/%([0-9A-F]{2})/g, (_, hex) =>
      String.fromCharCode(parseInt(hex, 16))
    )
  );
}

function decodeUnicode(str) {
  return decodeURIComponent(
    atob(str)
      .split('')
      .map(c => '%' + c.charCodeAt(0).toString(16).padStart(2, '0'))
      .join('')
  );
}

const emoji = encodeUnicode('Héllo wörld 🌍');
console.log(emoji);                  // "SMOpbGxvIHfDtnJsZCDwn4yN"
console.log(decodeUnicode(emoji));   // "Héllo wörld 🌍"

Node.js — Usando Buffer

En Node.js, el enfoque idiomático es la API Buffer, que maneja Unicode correctamente de forma predeterminada y es mucho más limpia que la solución del navegador anterior.

js
// Encoding
const encoded = Buffer.from('Hello, World!', 'utf8').toString('base64');
console.log(encoded);  // "SGVsbG8sIFdvcmxkIQ=="

// Decoding
const decoded = Buffer.from('SGVsbG8sIFdvcmxkIQ==', 'base64').toString('utf8');
console.log(decoded);  // "Hello, World!"

// Encoding a file to Base64 (e.g. to embed in a JSON payload)
const fs = require('fs');

function fileToBase64(filePath) {
  const fileBuffer = fs.readFileSync(filePath);
  return fileBuffer.toString('base64');
}

function base64ToFile(base64String, outputPath) {
  const fileBuffer = Buffer.from(base64String, 'base64');
  fs.writeFileSync(outputPath, fileBuffer);
}

const avatarBase64 = fileToBase64('./uploads/avatar.png');
const payload = {
  userId: 'usr_8f3k2',
  avatarData: avatarBase64,
  mimeType: 'image/png'
};

Python — El módulo base64

La biblioteca estándar de Python incluye un módulo base64 que maneja la codificación, decodificación y la variante segura para URL. Las funciones trabajan con objetos bytes, por lo que generalmente codificarás/decodificarás cadenas con un conjunto de caracteres explícito.

python
import base64

# Encoding a string
message = "Hello, World!"
encoded = base64.b64encode(message.encode("utf-8"))
print(encoded)           # b'SGVsbG8sIFdvcmxkIQ=='
print(encoded.decode())  # 'SGVsbG8sIFdvcmxkIQ=='

# Decoding
decoded_bytes = base64.b64decode("SGVsbG8sIFdvcmxkIQ==")
print(decoded_bytes.decode("utf-8"))  # 'Hello, World!'

# Encoding a file
with open("report.pdf", "rb") as f:
    pdf_base64 = base64.b64encode(f.read()).decode("utf-8")

# Embedding it in a JSON-compatible structure
import json
payload = {
    "filename": "report.pdf",
    "content": pdf_base64,
    "encoding": "base64"
}
print(json.dumps(payload, indent=2))

Base64 seguro para URL

El Base64 estándar usa + y /, que son caracteres especiales en las URL. Coloca una cadena Base64 estándar en un parámetro de consulta y obtendrás una corrupción sutil a menos que primero lo codifiques en porcentaje. El Base64 seguro para URL (también definido en RFC 4648 §5) soluciona esto reemplazando + con - y / con _. Los signos de relleno = a menudo se omiten completamente en contextos de URL.

js
// Standard → URL-safe conversion in JavaScript
function toBase64Url(base64) {
  return base64
    .replace(/+/g, '-')
    .replace(///g, '_')
    .replace(/=+$/, '');  // strip padding
}

function fromBase64Url(base64url) {
  // Restore padding
  const padded = base64url + '=='.slice(0, (4 - (base64url.length % 4)) % 4);
  return padded.replace(/-/g, '+').replace(/_/g, '/');
}

const standard = btoa('some binary  data');
const urlSafe  = toBase64Url(standard);

console.log(standard);  // "c29tZSBiaW5hcnkAAGRhdGE="
console.log(urlSafe);   // "c29tZSBiaW5hcnkAAGRhdGE"  (safe for URLs)

En Python, usa base64.urlsafe_b64encode() y base64.urlsafe_b64decode() — hacen la sustitución automáticamente.

Casos de uso comunes en el mundo real

  • Incrustar imágenes en HTML/CSS — un URI data: como src="data:image/png;base64,iVBORw0KGgo..." elimina una solicitud HTTP separada. Excelente para iconos pequeños y sprites; no tan bueno para imágenes grandes debido a la sobrecarga de tamaño del 33%.
  • Tokens JWT — las secciones de encabezado y carga útil de un JSON Web Token son objetos JSON codificados en Base64 seguro para URL. Las tres partes separadas por puntos que ves en un JWT son Base64Url(encabezado).Base64Url(carga).Base64Url(firma).
  • Autenticación HTTP básica — el encabezado Authorization: Basic ... codifica usuario:contraseña como Base64. Está definido en RFC 7617. Nota: esto es codificación, no cifrado — siempre usa HTTPS.
  • Incrustar datos binarios en JSON — JSON no tiene tipo binario, por lo que archivos, imágenes y certificados enviados a través de API generalmente se codifican en Base64 en un campo de cadena. Consulta las herramientas Archivo a Base64 e Imagen a Base64 para este flujo de trabajo.
  • Archivos adjuntos de correo electrónico — MIME (el formato subyacente del correo electrónico) usa Base64 para codificar archivos adjuntos binarios para que sobrevivan la transmisión a través de servidores de retransmisión de correo solo de texto. El problema original que Base64 fue diseñado para resolver.
  • Almacenar datos binarios en bases de datos — cuando necesitas almacenar un pequeño blob (un certificado, una miniatura) en una columna de texto o dentro de un documento JSON, Base64 es la elección estándar.

Base64 NO es cifrado

Esto confunde a la gente constantemente — especialmente al revisar código. Base64 es codificación, no cifrado. La codificación es una transformación reversible que cambia la representación de los datos. El cifrado codifica los datos usando una clave secreta para que solo alguien con la clave pueda revertirlo.

Cualquiera puede decodificar una cadena Base64 en segundos — pégala en Decodificador Base64 y listo. Nunca uses Base64 para "ocultar" valores sensibles como contraseñas, claves API o datos personales. Si necesitas confidencialidad, usa cifrado real (AES, RSA, o una biblioteca como Web Crypto API en el navegador, o cryptography en Python).

También vale la pena señalar: Base64 no es compresión. La salida siempre es más grande que la entrada — en aproximadamente un tercio. Si necesitas reducir el tamaño, comprime primero (gzip, Brotli, zstd), luego codifica en Base64 los bytes comprimidos si el canal requiere texto.

Herramientas para trabajar con Base64

Si trabajas con Base64 a diario, tener herramientas rápidas hace una diferencia real. Usa Codificador Base64 para codificar cualquier cadena de texto, Decodificador Base64 para decodificar e inspeccionar valores Base64, Archivo a Base64 para convertir archivos binarios para cargas API o almacenamiento, y Imagen a Base64 para generar URI de datos para incrustar imágenes directamente en HTML o CSS.

Conclusión

Base64 existe para resolver un problema específico: hacer pasar datos binarios a través de canales solo de texto sin corrupción. Lo hace mapeando cada 3 bytes de entrada a 4 caracteres ASCII imprimables, usando un alfabeto de 64 caracteres (A–Z, a–z, 0–9, +, /). El resultado es seguro para correo electrónico, cabeceras HTTP, campos JSON y URL (con la variante segura para URL). La compensación es un aumento fijo del 33% en el tamaño. No es cifrado, no es compresión — es una codificación transparente y reversible. Una vez que hayas interiorizado eso, sabrás inmediatamente cuándo usarlo y cuándo una herramienta diferente se adapta mejor.

← All Base64 articles Browse all categories →