> base64 | decode | JPG <
// Decodifica strings Base64 y URIs de datos de vuelta a fotos JPG / JPEG — con EXIF preservado, vista previa instantánea y descarga en un clic
El JPEG decodificado aparecerá aquí
Sin recompresión
Los bytes JPEG que salen del decodificador son idénticos bit a bit a lo que se codificó — misma calidad, mismos EXIF, mismos coeficientes DCT.
Decodificación local
Tu cadena Base64 se decodifica con atob() íntegramente en el navegador. Sin subidas. Sin servidor. Sin analítica sobre el payload.
Vista previa en vivo
Ve la foto decodificada y sus dimensiones inmediatamente — descárgala como .jpg con un clic.
// ACERCA DE BASE64 A JPG
Qué acepta esta herramienta
- >URI de datos: data:image/jpeg;base64,/9j/4AAQSkZ…
- >Payload Base64 de JPEG en crudo (empieza por /9j/)
- >Base64 con espacios / saltos de línea embebidos
- >Alfabeto estándar RFC 4648 (+/, padding = opcional)
- >Base64 URL-safe (-_) — se normaliza automáticamente al decodificar
- >JPEG multi-parte (marcadores JFIF, EXIF, Adobe, SPIFF)
Casos de uso habituales
- >Recuperar una foto desde una respuesta de API JSON
- >Extraer un avatar de perfil desde una columna TEXT de base de datos
- >Decodificar un campo de imagen de CMS almacenado como URI de datos
- >Reconstruir una foto desde una parte MIME de correo
- >Renderizar una captura de cámara enviada por WebSocket
- >Depurar una etiqueta <img src="data:image/jpeg;base64,…"> rota
- >Apps offline-first que cachean fotos como Base64
Cómo funciona la decodificación Base64 → JPG
El decodificador elimina cualquier prefijo de URI de datos, normaliza los espacios y los caracteres URL-safe, y luego llama a atob() para convertir cada grupo Base64 de 4 caracteres de vuelta en 3 bytes binarios. El resultado se envuelve en un Blob con tipo MIME image/jpeg y se previsualiza con una etiqueta <img>. Como Base64 es una transformación biyectiva de binario a texto, el JPEG de salida es idéntico bit a bit al original — su hash SHA-256 coincide y no se pierde calidad.
URI de datos JPEG de ejemplo:
data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/wAALCAABAAEBAREA/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAA/AKp//9k=
Rendimiento y compatibilidad
- >Decodificación O(n) en función de la longitud del payload — soporta 100 MB+ sin problema
- >Usa atob() + Uint8Array nativos — sin librerías de terceros
- >Soporta JPEG con EXIF completo de todos los grandes fabricantes de cámaras
- >Funciona en Chrome, Firefox, Safari, Edge y navegadores móviles
- >Vista previa con zoom mediante pellizco en dispositivos móviles
- >Descargas vía Blob URL — sin viaje al servidor
// CÓMO DECODIFICAR BASE64 A JPG
Paso 1: Pegar
Pega la cadena Base64 o la URI de datos completa en el campo de entrada
Paso 2: Decodificar
Haz clic en [DECODE] — el JPEG se renderiza al instante
Paso 3: Inspeccionar
Revisa la foto, sus dimensiones y el tamaño del archivo antes de guardar
Paso 4: Descargar
Haz clic en [DOWNLOAD .jpg] para guardar un JPEG idéntico bit a bit en disco
// EJEMPLOS DE CÓDIGO — BASE64 A JPG
JavaScript (Navegador)
// Decode Base64 → JPEG Blob → preview
const b64 = '/9j/4AAQSkZJRgAB...';
const bin = atob(b64);
const arr = new Uint8Array(bin.length);
for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
const blob = new Blob([arr], { type: 'image/jpeg' });
document.getElementById('preview').src = URL.createObjectURL(blob);Decodifica un payload Base64 de JPEG en crudo, envuélvelo en un Blob y renderízalo con <img>. Las URIs de datos pueden asignarse directamente a src.
Node.js
const fs = require('fs');
const b64 = '/9j/4AAQSkZJRgAB...';
fs.writeFileSync('out.jpg', Buffer.from(b64, 'base64'));Decodifica texto Base64 a un archivo JPEG usando el Buffer integrado de Node.
Python
import base64
with open('out.jpg', 'wb') as f:
f.write(base64.b64decode('/9j/4AAQSkZJRgAB...'))Solo biblioteca estándar — Base64 → bytes JPEG → archivo.
PHP
<?php
file_put_contents('out.jpg', base64_decode('/9j/4AAQSkZJRgAB...'));Una sola línea usando base64_decode() y file_put_contents().
Shell (macOS / Linux)
echo '/9j/4AAQSkZJRgAB...' | base64 -d > out.jpgbase64 -d de POSIX lee la cadena desde stdin y escribe el JPEG en disco.
// FAQ — BASE64 A JPG
P: ¿Qué es la decodificación Base64 a JPG?
R: Revierte un JPEG codificado en Base64 de vuelta a su forma binaria original. El decodificador lee 4 caracteres ASCII a la vez de la cadena Base64, los busca en el alfabeto del RFC 4648 y emite 3 bytes binarios por grupo. El array de bytes resultante es un archivo JPEG completo y válido — mismos coeficientes DCT, mismas tablas de Huffman, mismos metadatos EXIF, misma calidad que antes de codificar.
P: ¿Cómo puedo saber que la cadena Base64 es realmente un JPEG?
R: Cada JPEG empieza con los dos magic bytes FF D8 (Start-Of-Image). Cuando esos bytes se codifican en Base64, los 4 primeros caracteres son siempre /9j/. Así que cualquier cadena Base64 que empiece por /9j/4AAQ (cabecera JFIF) o /9j/2wC (muchas cámaras de smartphone que usan Adobe APP14) es un JPEG. Otros formatos tienen prefijos distintos: iVBORw0KGgo para PNG, R0lGOD para GIF, UklGR para WebP.
P: ¿Puedo decodificar una URI de datos directamente?
R: Sí. Si tu cadena empieza por data:image/jpeg;base64,, el decodificador elimina ese prefijo automáticamente y procesa el payload. Si solo tienes la parte Base64 en crudo, nuestra herramienta detecta el número mágico JPEG (/9j/) y envuelve los bytes decodificados como image/jpeg para la vista previa. Los espacios, saltos de línea y tabulaciones se eliminan antes de decodificar, así que puedes pegar un valor JSON con formato directamente.
P: ¿La decodificación reduce la calidad de mi JPEG?
R: No. La decodificación Base64 es una transformación binaria pura — cada carácter Base64 mapea de forma determinista a 6 bits, y 4 caracteres decodifican a 3 bytes. Los bytes JPEG que salen son idénticos bit a bit a lo que se codificó, así que la calidad es la que el JPEG original tuviera al guardarse. Un hash SHA-256 del archivo decodificado coincidirá con el hash del original. Si tu foto decodificada se ve peor de lo esperado, la pérdida de calidad ocurrió al guardar el JPEG por primera vez, no durante el round-trip de Base64.
P: El JPG decodificado está roto — ¿qué puede fallar?
R: Causas típicas:
• Cadena truncada — el Base64 se cortó en algún sitio. Un JPEG completo termina en FF D9 (End-Of-Image), que se codifica como /9k= o 2Q== en Base64. Si tu cadena no termina en uno de esos patrones más el padding opcional, está incompleta.
• Doble codificación — el JPEG se codificó en Base64 dos veces. Decodifícalo de nuevo.
• Alfabeto URL-safe — si la cadena usa -_ en lugar de +/, algunos decodificadores la rechazan. Nuestra herramienta normaliza ambos.
• En realidad es otro formato — el payload es PNG o WebP. Usa nuestro decodificador genérico Base64 → Imagen, que detecta el formato automáticamente.
P: ¿Se preservan mis metadatos EXIF tras la decodificación?
R: Sí. El segmento EXIF APP1 (modelo de cámara, GPS, fecha/hora, objetivo, ISO, balance de blancos, orientación, etc.) forma parte del flujo de bytes del JPEG. Como Base64 es reversible bit a bit, cada byte — incluidos los EXIF — se restaura. Si necesitas fotos sin EXIF por motivos de privacidad, elimina los metadatos después de decodificar usando una herramienta como exiftool -all= out.jpg o una re-exportación con canvas en el navegador.
P: ¿Puedo decodificar Base64 a JPG en la terminal?
R: Sí. En macOS y Linux: echo '/9j/4AAQSkZJRgAB…' | base64 -d > out.jpg
(el base64 de macOS antiguo usa -D.)
En Windows PowerShell: [IO.File]::WriteAllBytes('out.jpg', [Convert]::FromBase64String('/9j/4AAQSkZJRgAB…'))
Si tu entrada es una URI de datos completa, canalízala primero por sed 's|^data:.*base64,||' para eliminar el prefijo.
P: ¿De qué tamaño puede ser un Base64 de JPG que pueda decodificar?
R: Hasta el límite de memoria de tu navegador. Un JPEG decodificado de 100 MB necesita ~135 MB de texto Base64, que los navegadores de escritorio modernos manejan sin problema. Los navegadores móviles son fiables hasta ~40 MB. Para fotos extremadamente grandes (exportaciones JPEG convertidas desde RAW de cámaras de formato medio), considera la decodificación del lado del servidor: base64 -d photo.b64 > photo.jpg es mucho más rápido que un round-trip por el navegador.
P: ¿El decodificador funciona offline?
R: Sí, tras la carga inicial de la página. Toda la decodificación usa APIs integradas del navegador (atob(), Uint8Array, Blob, URL.createObjectURL()), ninguna de las cuales requiere conexión de red. Puedes confirmarlo deshabilitando tu red y seguir decodificando — la vista previa y la descarga siguen funcionando.
P: ¿El JPEG Base64 está cifrado o es privado?
R: No. Base64 es una codificación, no cifrado. Cualquiera con tu cadena Base64 puede decodificarla de vuelta a la foto original en milisegundos, y los datos EXIF (incluidas las coordenadas GPS) van incluidos. Si el JPEG contiene información sensible, ciframos (AES-GCM, age, PGP) antes de aplicar Base64, y transpórtalo siempre por HTTPS.
P: ¿La decodificación es del lado del cliente — se sube algo?
R: No se sube nada. Cada paso — quitar el prefijo, normalizar espacios, llamar a atob(), construir el Blob, renderizar el <img>, disparar la descarga — ocurre en tu navegador. Abre la pestaña Red de las DevTools de tu navegador mientras decodificas y verás cero peticiones salientes para tu payload Base64. Esta herramienta es segura para capturas confidenciales, fotos personales y datos regulados.
P: ¿Cómo decodifico Base64 a JPG en código de producción?
R: En Node.js: fs.writeFileSync('out.jpg', Buffer.from(b64, 'base64')). En Python: open('out.jpg','wb').write(base64.b64decode(b64)). En Go: b, _ := base64.StdEncoding.DecodeString(b64); os.WriteFile("out.jpg", b, 0644). En Java: Files.write(Path.of("out.jpg"), Base64.getDecoder().decode(b64)). En Rust: std::fs::write("out.jpg", base64::decode(b64)?)?. En Ruby: File.binwrite('out.jpg', Base64.decode64(b64)). En PHP: file_put_contents('out.jpg', base64_decode($b64)).
P: Base64 a JPG vs Base64 a PNG — ¿cuál debería usar?
R: Fíjate en el prefijo de la cadena Base64. Si empieza por /9j/, es JPEG — usa Base64 → JPG. Si empieza por iVBORw0KGgo, es PNG — usa Base64 → PNG. No puedes forzar a un decodificador JPEG a emitir PNG (ni viceversa); los magic bytes dicen la verdad. En caso de duda, usa el decodificador genérico, que detecta el formato automáticamente y guarda con la extensión correcta.