> base64 | decode | JPG <
// Decodifica stringhe Base64 e data URI in foto JPG / JPEG — EXIF preservato, anteprima istantanea, download con un clic
Il JPEG decodificato apparirà qui
Nessuna ricompressione
I byte JPEG in uscita dal decodificatore sono bit per bit identici a ciò che è stato codificato — stessa qualità, stessi EXIF, stessi coefficienti DCT.
Decodifica locale
La tua stringa Base64 viene decodificata con atob() interamente nel browser. Nessun upload. Nessun server. Nessuna analisi sul payload.
Anteprima dal vivo
Visualizza subito la foto decodificata e le sue dimensioni — scaricala come .jpg con un clic.
// INFORMAZIONI SU BASE64 IN JPG
Cosa accetta questo strumento
- >Data URI: data:image/jpeg;base64,/9j/4AAQSkZ…
- >Payload Base64 JPEG grezzo (inizia con /9j/)
- >Base64 con spazi bianchi / a capo incorporati
- >Alfabeto standard RFC 4648 (+/, riempimento = opzionale)
- >Base64 URL-safe (-_) — normalizzato automaticamente alla decodifica
- >JPEG multiparte (marcatori JFIF, EXIF, Adobe, SPIFF)
Casi d'uso comuni
- >Recuperare una foto da una risposta JSON API
- >Estrarre un avatar di profilo da una colonna TEXT di database
- >Decodificare un campo immagine CMS salvato come data URI
- >Ricostruire una foto da una parte MIME di un'email
- >Visualizzare uno scatto della fotocamera inviato via WebSocket
- >Eseguire il debug di un tag <img src="data:image/jpeg;base64,…"> non funzionante
- >App offline-first che memorizzano le foto in cache come Base64
Come funziona la decodifica Base64 → JPG
Il decodificatore rimuove qualsiasi prefisso data URI, normalizza gli spazi bianchi e i caratteri URL-safe, quindi chiama atob() per riconvertire ogni gruppo Base64 di 4 caratteri in 3 byte binari. Il risultato viene incapsulato in un Blob con tipo MIME image/jpeg e visualizzato in anteprima con un tag <img>. Poiché Base64 è una trasformazione binaria-a-testo biiettiva, il JPEG in uscita è bit per bit identico all'originale — il suo hash SHA-256 corrisponde e non si perde alcuna qualità.
Esempio di data URI JPEG:
data:image/jpeg;base64,/9j/4AAQSkZJRgABAQEASABIAAD/2wBDAAYEBQYFBAYGBQYHBwYIChAKCgkJChQODwwQFxQYGBcUFhYaHSUfGhsjHBYWICwgIyYnKSopGR8tMC0oMCUoKSj/wAALCAABAAEBAREA/8QAFQABAQAAAAAAAAAAAAAAAAAAAAv/xAAUEAEAAAAAAAAAAAAAAAAAAAAA/9oACAEBAAA/AKp//9k=
Prestazioni e compatibilità
- >La decodifica è O(n) sulla lunghezza del payload — gestisce 100 MB+ senza problemi
- >Usa atob() + Uint8Array nativi — nessuna libreria di terze parti
- >Supporta JPEG ricchi di EXIF di tutti i principali produttori di fotocamere
- >Funziona in Chrome, Firefox, Safari, Edge e nei browser mobili
- >Anteprima con zoom a pizzico sui dispositivi mobili
- >Download tramite Blob URL — nessuna andata e ritorno al server
// COME DECODIFICARE BASE64 IN JPG
Passo 1: Incolla
Incolla la stringa Base64 o il data URI completo nel campo di input
Passo 2: Decodifica
Clicca su [DECODE] — il JPEG viene visualizzato istantaneamente
Passo 3: Ispeziona
Controlla la foto, le sue dimensioni e la dimensione del file prima di salvare
Passo 4: Scarica
Clicca su [DOWNLOAD .jpg] per salvare su disco un JPEG bit per bit identico
// ESEMPI DI CODICE — BASE64 IN JPG
JavaScript (Browser)
// 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 JPEG grezzo, incapsulalo in un Blob e visualizzalo con <img>. I data URI possono essere impostati direttamente su src.
Node.js
const fs = require('fs');
const b64 = '/9j/4AAQSkZJRgAB...';
fs.writeFileSync('out.jpg', Buffer.from(b64, 'base64'));Decodifica testo Base64 in un file JPEG usando il Buffer integrato di Node.
Python
import base64
with open('out.jpg', 'wb') as f:
f.write(base64.b64decode('/9j/4AAQSkZJRgAB...'))Solo libreria standard — Base64 → byte JPEG → file.
PHP
<?php
file_put_contents('out.jpg', base64_decode('/9j/4AAQSkZJRgAB...'));Una riga con base64_decode() e file_put_contents().
Shell (macOS / Linux)
echo '/9j/4AAQSkZJRgAB...' | base64 -d > out.jpgPOSIX base64 -d legge la stringa da stdin e scrive il JPEG su disco.
// FAQ — BASE64 IN JPG
D: Cos'è la decodifica Base64 in JPG?
R: Inverte un JPEG codificato in Base64 riportandolo alla sua forma binaria originale. Il decodificatore legge 4 caratteri ASCII alla volta dalla stringa Base64, li cerca nell'alfabeto RFC 4648 e produce 3 byte binari per gruppo. L'array di byte risultante è un file JPEG completo e valido — stessi coefficienti DCT, stesse tabelle di Huffman, stessi metadati EXIF, stessa qualità di prima della codifica.
D: Come posso capire se la stringa Base64 è davvero un JPEG?
R: Ogni JPEG inizia con i due byte magici FF D8 (Start-Of-Image). Quando quei byte vengono codificati in Base64, i primi 4 caratteri sono sempre /9j/. Quindi qualsiasi stringa Base64 che inizia con /9j/4AAQ (intestazione JFIF) o /9j/2wC (molte fotocamere di smartphone che usano Adobe APP14) è un JPEG. Altri formati hanno prefissi diversi: iVBORw0KGgo per PNG, R0lGOD per GIF, UklGR per WebP.
D: Posso decodificare un data URI direttamente?
R: Sì. Se la tua stringa inizia con data:image/jpeg;base64,, il decodificatore rimuove automaticamente quel prefisso ed elabora il payload. Se hai solo la parte Base64 grezza, il nostro strumento rileva il numero magico JPEG (/9j/) e incapsula i byte decodificati come image/jpeg per l'anteprima. Spazi bianchi, a capo e tabulazioni vengono tutti rimossi prima della decodifica, così puoi incollare direttamente un valore JSON formattato.
D: La decodifica riduce la qualità del mio JPEG?
R: No. La decodifica Base64 è una pura trasformazione binaria — ogni carattere Base64 mappa in modo deterministico a 6 bit, e 4 caratteri si decodificano in 3 byte. I byte JPEG in uscita sono bit per bit identici a ciò che è stato codificato, quindi la qualità è quella con cui il JPEG originale è stato salvato. Un hash SHA-256 del file decodificato corrisponderà all'hash dell'originale. Se la foto decodificata sembra peggiore del previsto, la perdita di qualità è avvenuta quando il JPEG è stato salvato la prima volta, non durante l'andata e ritorno Base64.
D: Il JPG decodificato è danneggiato — cosa potrebbe esserci che non va?
R: Cause tipiche:
• Stringa troncata — il Base64 è stato tagliato da qualche parte. Un JPEG completo termina con FF D9 (End-Of-Image), che in Base64 si codifica come /9k= o 2Q==. Se la tua stringa non termina con uno di questi pattern più il riempimento opzionale, è incompleta.
• Doppiamente codificata — il JPEG è stato codificato in Base64 due volte. Decodificalo di nuovo.
• Alfabeto URL-safe — se la stringa usa -_ invece di +/, alcuni decodificatori la rifiutano. Il nostro strumento normalizza entrambi.
• In realtà un formato diverso — il payload è PNG o WebP. Usa il nostro decodificatore generico Base64 → Immagine che rileva automaticamente il formato.
D: I miei metadati EXIF vengono preservati dopo la decodifica?
R: Sì. Il segmento EXIF APP1 (modello della fotocamera, GPS, data/ora, obiettivo, ISO, bilanciamento del bianco, orientamento, ecc.) fa parte del flusso di byte JPEG. Poiché Base64 è reversibile bit per bit, ogni byte — incluso EXIF — viene ripristinato. Se hai bisogno di foto senza EXIF per motivi di privacy, rimuovi i metadati dopo la decodifica con uno strumento come exiftool -all= out.jpg o una riesportazione basata su canvas nel browser.
D: Posso decodificare Base64 in JPG nel terminale?
R: Sì. Su macOS e Linux: echo '/9j/4AAQSkZJRgAB…' | base64 -d > out.jpg
(il base64 di macOS più vecchio usa -D.)
Su Windows PowerShell: [IO.File]::WriteAllBytes('out.jpg', [Convert]::FromBase64String('/9j/4AAQSkZJRgAB…'))
Se il tuo input è un data URI completo, passalo prima attraverso sed 's|^data:.*base64,||' per rimuovere il prefisso.
D: Quanto può essere grande un Base64 JPG che posso decodificare?
R: Fino al limite di memoria del tuo browser. Un JPEG decodificato da 100 MB richiede ~135 MB di testo Base64, che i browser desktop moderni gestiscono senza problemi. I browser mobili sono affidabili fino a ~40 MB. Per foto estremamente grandi (esportazioni JPEG convertite da RAW di fotocamere di medio formato), considera la decodifica lato server: base64 -d photo.b64 > photo.jpg è molto più veloce di un'andata e ritorno del browser.
D: Il decodificatore funziona offline?
R: Sì, dopo il caricamento iniziale della pagina. Tutta la decodifica usa API integrate del browser (atob(), Uint8Array, Blob, URL.createObjectURL()), nessuna delle quali richiede una connessione di rete. Puoi confermarlo disabilitando la rete e continuando a decodificare — l'anteprima e il download continuano entrambi a funzionare.
D: Il JPEG in Base64 è crittografato o privato?
R: No. Base64 è una codifica, non una crittografia. Chiunque abbia la tua stringa Base64 può decodificarla riportandola alla foto originale in millisecondi, e i dati EXIF (incluse le coordinate GPS) vengono inclusi. Se il JPEG contiene informazioni sensibili, crittografalo (AES-GCM, age, PGP) prima di applicare Base64, e trasporta la stringa esclusivamente tramite HTTPS.
D: La decodifica è lato client — viene caricato qualcosa?
R: Nulla viene caricato. Ogni passaggio — rimozione del prefisso, normalizzazione degli spazi bianchi, chiamata ad atob(), costruzione del Blob, rendering dell'<img>, attivazione del download — avviene nel tuo browser. Apri la scheda Rete dei dev-tools del browser durante la decodifica e vedrai zero richieste in uscita per il tuo payload Base64. Questo strumento è sicuro per screenshot riservati, foto personali e dati regolamentati.
D: Come decodifico Base64 in JPG nel codice di produzione?
R: In Node.js: fs.writeFileSync('out.jpg', Buffer.from(b64, 'base64')). In Python: open('out.jpg','wb').write(base64.b64decode(b64)). In Go: b, _ := base64.StdEncoding.DecodeString(b64); os.WriteFile("out.jpg", b, 0644). In Java: Files.write(Path.of("out.jpg"), Base64.getDecoder().decode(b64)). In Rust: std::fs::write("out.jpg", base64::decode(b64)?)?. In Ruby: File.binwrite('out.jpg', Base64.decode64(b64)). In PHP: file_put_contents('out.jpg', base64_decode($b64)).
D: Base64 in JPG vs Base64 in PNG — quale dovrei usare?
R: Guarda il prefisso della stringa Base64. Se inizia con /9j/, è JPEG — usa Base64 → JPG. Se inizia con iVBORw0KGgo, è PNG — usa Base64 → PNG. Non puoi forzare un decodificatore JPEG a produrre PNG (o viceversa); i byte magici dicono la verità. In caso di dubbio, usa il decodificatore generico che rileva automaticamente il formato e salva con l'estensione corretta.