Decodificador de Imagem Base64

O que é decodificação de imagens Base64?

A decodificação de imagens Base64 é o oposto da codificação: ela pega uma string Base64 ou data URI que representa uma imagem e a converte novamente em dados binários visíveis. Quando você recebe uma string como data:image/png;base64,iVBORw0KGgo..., a decodificação remove o prefixo de data URI, reverte a codificação Base64 definida em RFC 4648 e reconstrói os bytes originais da imagem. O navegador pode então renderizar os bytes decodificados como uma imagem visível.

Data URIs (RFC 2397) agrupam o tipo MIME e o conteúdo codificado em Base64 em uma única string. Eles aparecem frequentemente em respostas de API, código-fonte de e-mail HTML, folhas de estilo CSS e registros de banco de dados onde as imagens são armazenadas como texto em vez de arquivos binários. Decodificar essas strings é necessário para visualizar a imagem, verificar seu conteúdo ou salvá-la como um arquivo independente. Como Base64 usa 4 caracteres ASCII para representar cada 3 bytes de dados binários, a string codificada é sempre aproximadamente 33% maior que a imagem original.

Esta ferramenta analisa tanto data URIs completos (data:image/png;base64,...) quanto strings Base64 sem o prefixo data:. Para strings sem prefixo, o formato da imagem é detectado automaticamente inspecionando os primeiros caracteres Base64, que correspondem aos magic bytes do arquivo — por exemplo, iVBORw0KGgo sempre indica um arquivo PNG. A imagem decodificada é renderizada diretamente no navegador e pode ser baixada como um arquivo.

Um cenário comum é trabalhar com uma API REST que retorna uma foto de perfil ou miniatura de documento como uma string Base64 dentro de um campo JSON — por exemplo, {"avatar": "data:image/png;base64,iVBORw0KGgo..."}. Para usar a imagem, você extrai o valor do campo, remove o prefixo de data URI até a vírgula inclusive, e alimenta os caracteres Base64 restantes através de um decodificador como atob() em JavaScript ou base64.b64decode() em Python para recuperar os bytes originais. Colar o valor completo nesta ferramenta pula todas essas etapas manuais e renderiza a imagem imediatamente.

Por que usar este decodificador de imagens Base64?

Esta ferramenta converte dados de imagens Base64 novamente em uma imagem visível e descarregável completamente em seu navegador — sem upload, sem processamento no servidor, sem conta necessária.

Casos de uso de decodificação de imagens Base64

Estrutura de Data URI para imagens

Um data URI empacota o tipo de imagem e o conteúdo codificado em uma única string. Cada componente é essencial para uma decodificação correta: o esquema (data:) sinaliza que a URL é autossuficiente em vez de uma referência a um recurso externo; o tipo MIME (por exemplo, image/png) informa ao renderizador qual formato usar ao interpretar os bytes brutos; o marcador ;base64, distingue conteúdo codificado em Base64 de data URIs que usam codificação de porcentagem para formatos de texto simples. O payload Base64 em si pode terminar com um ou dois caracteres de preenchimento = — estes são necessários quando a contagem de bytes de entrada não é múltipla de três, garantindo que o comprimento codificado seja sempre múltiplo de quatro. Omitir ou truncar qualquer um desses componentes causa falha de decodificação ou produz uma imagem corrompida.

Detectando formato de imagem a partir de Base64

Quando uma string Base64 não tem um prefixo data:, o formato da imagem pode ser identificado inspecionando os primeiros caracteres. Esses caracteres correspondem aos magic bytes do arquivo — sequências de bytes fixas no início de cada arquivo de imagem que identificam o formato:

Exemplos de código

Como decodificar strings de imagens Base64 de volta para arquivos de imagem em linguagens e ambientes populares:

// Decode a Base64 data URI to a Blob and create a download link
const dataUri = 'data:image/png;base64,iVBORw0KGgo...'

// Method 1: fetch API (simplest)
const res  = await fetch(dataUri)
const blob = await res.blob()
// blob.type → "image/png", blob.size → 2048

// Method 2: manual decode for older environments
const [header, b64] = dataUri.split(',')
const mime    = header.match(/:(.*?);/)[1]   // → "image/png"
const binary  = atob(b64)
const bytes   = Uint8Array.from(binary, c => c.charCodeAt(0))
const blob2   = new Blob([bytes], { type: mime })

// Create a download link
const url = URL.createObjectURL(blob)
const a   = document.createElement('a')
a.href = url
a.download = 'decoded.png'
a.click()
URL.revokeObjectURL(url)

import base64
import re

data_uri = 'data:image/png;base64,iVBORw0KGgo...'

# Parse the data URI
match = re.match(r'data:(image/[\w+.-]+);base64,(.+)', data_uri)
mime_type = match.group(1)    # → "image/png"
b64_data  = match.group(2)

# Decode and write to file
image_bytes = base64.b64decode(b64_data)
ext = mime_type.split('/')[1].replace('jpeg', 'jpg').replace('svg+xml', 'svg')

with open(f'output.{ext}', 'wb') as f:
    f.write(image_bytes)
# → writes output.png (byte-for-byte identical to the original)

# Decode raw Base64 (no data: prefix)
raw_b64 = 'iVBORw0KGgo...'
image_bytes = base64.b64decode(raw_b64)

import { writeFileSync } from 'fs'

const dataUri = 'data:image/png;base64,iVBORw0KGgo...'

// Extract MIME type and Base64 payload
const [meta, b64] = dataUri.split(',')
const mime = meta.match(/:(.*?);/)[1]  // → "image/png"

// Decode to Buffer and save
const buffer = Buffer.from(b64, 'base64')
writeFileSync('output.png', buffer)
// → output.png (identical to the original file)

// Validate by checking magic bytes
console.log(buffer.subarray(0, 4))
// PNG → <Buffer 89 50 4e 47>  (\x89PNG)
// JPEG → <Buffer ff d8 ff e0>

# Decode a raw Base64 string to an image file (Linux)
echo 'iVBORw0KGgo...' | base64 -d > output.png

# Decode a raw Base64 string to an image file (macOS)
echo 'iVBORw0KGgo...' | base64 -D > output.png

# Extract Base64 from a data URI and decode
echo 'data:image/png;base64,iVBORw0KGgo...' | \
  sed 's/^data:.*base64,//' | base64 -d > output.png

# Identify the image format from the decoded file
file output.png
# → output.png: PNG image data, 64 x 64, 8-bit/color RGBA

Perguntas frequentes