Codificación y Decodificación Base64: Cuándo y Cómo Usarla

31 de marzo de 2026 · 12 min de lectura

¿Qué es la Codificación Base64?

Base64 es un esquema de codificación binario a texto que convierte datos binarios en una cadena de caracteres ASCII. Utiliza 64 caracteres imprimibles (A-Z, a-z, 0-9, +, /) más el signo igual (=) para el relleno. El nombre "Base64" proviene del uso de una base de 64 caracteres distintos para representar datos binarios.

Esto es lo que hace esencial a Base64: te permite transportar datos binarios de forma segura a través de sistemas diseñados exclusivamente para texto. Antes de Base64, enviar una imagen por correo electrónico o incrustar datos binarios en JSON corrompería los datos o rompería el sistema por completo.

Base64 no es encriptación — esta es una distinción crítica. No proporciona seguridad ni ofuscación. Cualquiera puede decodificar Base64 instantáneamente sin una clave o contraseña. Es puramente un esquema de codificación diseñado para compatibilidad, no para confidencialidad.

Te encuentras con Base64 todos los días, a menudo sin darte cuenta:

• Archivos adjuntos de correo electrónico transmitidos mediante codificación MIME
• URLs de datos que incrustan imágenes directamente en HTML y CSS
• JWT (JSON Web Tokens) utilizados para autenticación
• Encabezados de autenticación de API (Basic Auth)
• Fuentes y recursos incrustados en aplicaciones web
• Datos binarios almacenados en documentos JSON o XML
• Archivos de certificados y claves criptográficas

Cómo Funciona Base64 Internamente

Base64 convierte cada 3 bytes (24 bits) de datos de entrada en 4 caracteres (6 bits cada uno). Esta relación matemática es la base de cómo Base64 mantiene la integridad de los datos mientras los convierte a texto.

Veamos un ejemplo completo codificando el texto "Hi":

1. Convertir a bytes ASCII: "Hi" se convierte en 72, 105
2. Convertir a binario: 01001000 01101001 (16 bits en total)
3. Agrupar en fragmentos de 6 bits: 010010 | 000110 | 1001xx
4. Rellenar el grupo incompleto: 010010 | 000110 | 100100
5. Mapear al alfabeto Base64: S (18), G (6), k (36)
6. Agregar caracteres de relleno: SGk=

El carácter de relleno (=) indica cuántos bytes faltaban en el grupo final. Un = significa que faltaba un byte, dos = significa que faltaban dos bytes.

El Conjunto de Caracteres Base64

Los 64 caracteres utilizados en la codificación Base64 estándar se eligen cuidadosamente para ser universalmente seguros en diferentes sistemas:

El Compromiso de Tamaño

Dado que cada 3 bytes de entrada se convierten en 4 caracteres de salida, Base64 aumenta el tamaño de los datos aproximadamente un 33%. Este es el compromiso fundamental para lograr un transporte seguro de texto.

Por ejemplo:

• Un archivo binario de 3 KB se convierte en 4 KB cuando se codifica en Base64
• Una imagen de 100 KB se convierte en 133 KB
• Un PDF de 1 MB se convierte en 1.33 MB

Este aumento de tamaño es importante a considerar al decidir si Base64 es apropiado para tu caso de uso.

Cuándo Usar Base64

Base64 brilla en escenarios específicos donde los datos binarios deben pasar a través de sistemas de solo texto. Comprender estos casos de uso te ayuda a tomar decisiones informadas sobre cuándo la codificación es apropiada.

Archivos Adjuntos de Correo Electrónico y MIME

SMTP (Simple Mail Transfer Protocol) fue diseñado en 1982 solo para texto ASCII de 7 bits. Cuando adjuntas un PDF, imagen o cualquier archivo binario a un correo electrónico, tu cliente de correo lo codifica automáticamente en Base64.

El estándar MIME (Multipurpose Internet Mail Extensions) utiliza Base64 como su método principal de codificación para archivos adjuntos binarios. Esto asegura que tus archivos lleguen intactos independientemente de los servidores de correo por los que pasen.

URLs de Datos en Desarrollo Web

Las URLs de datos te permiten incrustar archivos pequeños directamente en HTML, CSS o JavaScript en lugar de hacer solicitudes HTTP separadas. Esto es particularmente útil para:

• Iconos y logotipos pequeños (menores de 5 KB)
• Spinners de carga y elementos de UI
• Alternativas SVG inline
• Imágenes de fondo CSS críticas

Ejemplo de estructura de URL de datos:

data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAUA...

Autenticación de API

La Autenticación Básica HTTP codifica las credenciales en formato Base64. Cuando envías un nombre de usuario y contraseña, se combinan con dos puntos y se codifican en Base64:

Authorization: Basic dXNlcm5hbWU6cGFzc3dvcmQ=

Esta codificación hace que el encabezado sea seguro para la transmisión HTTP, aunque las credenciales se decodifican fácilmente (por lo que HTTPS es esencial).

Transporte de Datos JSON y XML

JSON y XML son formatos basados en texto que no pueden contener directamente datos binarios. Cuando necesitas incluir contenido binario en estos formatos, la codificación Base64 es la solución estándar:

• Almacenar imágenes en documentos MongoDB
• Transmitir cargas de archivos a través de APIs REST
• Incrustar datos binarios en archivos de configuración
• Incluir certificados en JSON Web Keys (JWK)

Tokens JWT

Los JSON Web Tokens utilizan codificación Base64URL (una variante segura para URL) para sus tres componentes: encabezado, carga útil y firma. Esto permite que los JWT se transmitan de forma segura en URLs, encabezados HTTP y cookies.

Base64 en JavaScript

JavaScript proporciona funciones integradas para codificación y decodificación Base64, aunque funcionan de manera diferente en navegadores versus entornos Node.js.

Entorno del Navegador

Los navegadores modernos incluyen las funciones btoa() (binario a ASCII) y atob() (ASCII a binario):

// Codificación
const encoded = btoa('Hello, World!');
console.log(encoded); // SGVsbG8sIFdvcmxkIQ==

// Decodificación
const decoded = atob('SGVsbG8sIFdvcmxkIQ==');
console.log(decoded); // Hello, World!

Limitación importante: btoa() solo funciona con cadenas que contienen caracteres en el rango Latin1 (0-255). Para cadenas Unicode, necesitas un paso adicional:

// Codificar cadenas Unicode
function encodeUnicode(str) {
  return btoa(encodeURIComponent(str).replace(/%([0-9A-F]{2})/g,
    (match, p1) => String.fromCharCode('0x' + p1)
  ));
}

// Decodificar cadenas Unicode
function decodeUnicode(str) {
  return decodeURIComponent(atob(str).split('').map(c =>
    '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2)
  ).join(''));
}

const encoded = encodeUnicode('Hello 世界');
console.log(encoded); // SGVsbG8g5LiW55WM

Entorno Node.js

Node.js utiliza la API Buffer para operaciones Base64, que maneja datos binarios y Unicode correctamente:

// Codificación
const encoded = Buffer.from('Hello, World!').toString('base64');
console.log(encoded); // SGVsbG8sIFdvcmxkIQ==

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

// Funciona perfectamente con Unicode
const unicodeEncoded = Buffer.from('Hello 世界').toString('base64');
console.log(unicodeEncoded); // SGVsbG8g5LiW55WM

Codificar Archivos en Node.js

Leer y codificar archivos es sencillo con Node.js:

const fs = require('fs');

// Leer y codificar un archivo
const fileBuffer = fs.readFileSync('image.png');
const base64Image = fileBuffer.toString('base64');

// Guardar datos codificados
fs.writeFileSync('image.txt', base64Image);

// Decodificar y guardar
const decodedBuffer = Buffer.from(base64Image, 'base64');
fs.writeFileSync('image-copy.png', decodedBuffer);

Base64 en Python

El módulo base64 de Python proporciona funcionalidad integral de codificación y decodificación con excelente soporte Unicode.

Codificación y Decodificación Básica

import base64

# Codificar cadenas
text = "Hello, World!"
encoded = base64.b64encode(text.encode('utf-8'))
print(encoded)  # b'SGVsbG8sIFdvcmxkIQ=='

# Decodificar
decoded = base64.b64decode(encoded).decode('utf-8')
print(decoded)  # Hello, World!

# Unicode funciona sin problemas
unicode_text = "Hello 世界"
encoded_unicode = base64.b64encode(unicode_text.encode('utf-8'))
print(encoded_unicode)  # b'SGVsbG8g5LiW55WM'

Trabajar con Archivos

Python hace que la codificación y decodificación de archivos sea simple:

import base64

# Codificar un archivo
with open('image.png', 'rb') as file:
    encoded = base64.b64encode(file.read())
    
with open('image.txt', 'wb') as file:
    file.write(encoded)

# Decodificar un archivo
with open('image.txt', 'rb') as file:
    decoded = base64.b64decode(file.read())
    
with open('image-copy.png', 'wb') as file:
    file.write(decoded)

Codificación Segura para URL

Python incluye variantes Base64 seguras para URL que reemplazan caracteres problemáticos:

import base64

text = "Hello, World!"
encoded_bytes = text.encode('utf-8')

# Base64 estándar
standard = base64.b64encode(encoded_bytes)
print(standard)  # b'SGVsbG8sIFdvcmxkIQ=='

# Base64 seguro para URL (reemplaza + con - y / con _)
urlsafe = base64.urlsafe_b64encode(encoded_bytes)
print(urlsafe)  # b'SGVsbG8sIFdvcmxkIQ=='

# Decodificar seguro para URL
decoded = base64.urlsafe_b64decode(urlsafe).decode('utf-8')
print(decoded)  # Hello, World!

Codificar para URLs de Datos

Crear URLs de datos en Python para uso web:

import base64
import mimetypes

def create_data_url(filepath):
    mime_type, _ = mimetypes.guess_type(filepath)
    with open(filepath, 'rb') as file:
        encoded = base64.b64encode(file.read()).decode('utf-8')
    return f"data:{mime_type};base64,{encoded}"

# Uso
data_url = create_data_url('logo.png')
print(data_url[:50])  # data:image/png;base64,iVBORw0KGgoAAAANSUhEU...

Base64 en la Línea de Comandos

Los sistemas tipo Unix incluyen el comando base64 para operaciones rápidas de codificación y decodificación directamente en la terminal.

Uso Básico

# Codificar una cadena
echo "Hello, World!" | base64
# Salida: SGVsbG8sIFdvcmxkIQo=

# Decodificar una cadena
echo "SGVsbG8sIFdvcmxkIQo=" | base64 -d
# Salida: Hello, World!

# Codificar un archivo
base64 image.png > image.txt

# Decodificar un archivo
base64 -d image.txt > image-copy.png

# Codificar sin saltos de línea (útil para URLs de datos)
base64 -w 0 image.png > image-oneline.txt

Diferencias en macOS

En macOS, el comando base64 tiene opciones ligeramente diferentes:

# Decodificar en macOS
base64 -D image.txt > image-copy.png

# Codificar sin saltos de línea en macOS
base64 -b 0 image.png > image-oneline.txt

Ejemplos Prácticos de Línea de Comandos

# Crear una URL de datos desde una imagen
echo "data:image/png;base64,$(base64 -w 0 logo.png)"

# Codificar contenido del portapapeles (Linux con xclip)
xclip -o | base64

# Encabezado de autenticación API rápido
echo -n "username:password" | base64
# Salida: dXNlcm5hbWU6cGFzc3dvcmQ=

# Verificar integridad del archivo después de codificar/decodificar
md5sum original.pdf
base64 original.pdf | base64 -d | md5sum
# Ambas sumas de verificación deben coincidir

URLs de Datos e Imágenes Inline

Las URLs de datos incrustan contenido de archivos directamente en HTML, CSS o JavaScript usando codificación Base64. Esto elimin