Por que o tamanho do arquivo aumenta 33% com codificação Base64

Você já ouviu dizer que 「o tamanho do arquivo aumenta cerca de 33% quando codificado em Base64」? Por que é assim? Este artigo explica como o Base64 encoding funciona, as razões matemáticas para o aumento do tamanho do arquivo e seu impacto no desenvolvimento.

O que é Base64

Base64 é um método de codificação que representa dados binários usando apenas caracteres ASCII. É usado para transmitir dados binários em protocolos que lidam apenas com texto, como anexos de email (MIME), esquemas de URI de dados, tokens JWT e cabeçalhos de autenticação básica.

Os caracteres usados são <code>A–Z</code> (26 caracteres), <code>a–z</code> (26 caracteres), <code>0–9</code> (10 caracteres), <code>+</code>, <code>/</code>, totalizando 64 caracteres (＝Base<strong>64</strong>), além de <code>=</code> para preenchimento.

Por que aumenta 33%

Base64 <strong>converte 3 bytes binários em 4 caracteres ASCII</strong>.

• 3 bytes = 24 bits
• 24 bits ÷ 6 bits = 4 caracteres Base64 (cada caractere representa 6 bits)

Em outras palavras, os dados originais se tornam <strong>3 bytes → 4 caracteres</strong>. A razão de tamanho é <code>4 ÷ 3 ≈ 1.333...</code>, portanto, há um aumento de <strong>aproximadamente 33,3%</strong>.

元バイナリ:   | 0x4D | 0x61 | 0x6E |  ← 3バイト
              01001101 01100001 01101110
              ↓ 6ビットずつに分割
              010011 010110 000101 101110
              ↓ Base64文字に変換
                 T       W       F       u   ← 4文字（= 4バイト）

Cálculo do aumento de tamanho concreto

A fórmula de cálculo exata é a seguinte.

import math

def base64_size(original_bytes: int) -> int:
    """Base64エンコード後のバイト数を計算"""
    # 3バイトを4文字に変換、4の倍数にパディング
    return math.ceil(original_bytes / 3) * 4

original = 10_000_000  # 10 MB
encoded  = base64_size(original)
print(f"元: {original:,} B")
print(f"後: {encoded:,} B")
print(f"増加率: {encoded/original*100:.1f}%")
# → 元: 10,000,000 B
# → 後: 13,333,336 B
# → 増加率: 133.3%

Aumento adicional devido a caracteres de quebra de linha

No padrão MIME (email), dados em Base64 devem ser quebrados a cada 76 caracteres com <code>\r\n</code> (CRLF). Essas quebras de linha também adicionam bytes, aumentando ligeiramente o tamanho.

def base64_mime_size(original_bytes: int, line_length: int = 76) -> int:
    """MIME形式（76文字改行）のBase64サイズを計算"""
    b64_chars = math.ceil(original_bytes / 3) * 4
    line_count = math.ceil(b64_chars / line_length)
    return b64_chars + line_count * 2  # CRLF = 2バイト/行

Impacto no desenvolvimento

Envio de arquivo via API

Ao enviar um arquivo incluído no corpo JSON de uma API REST, é necessário fazer a codificação Base64.

// ファイルをBase64に変換してJSONで送る
const file = document.getElementById('file').files[0];
const reader = new FileReader();
reader.onload = (e) => {
    const base64 = e.target.result; // "data:image/png;base64,iVBORw0KGgo..."
    fetch('/api/upload', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: JSON.stringify({ file: base64, name: file.name })
    });
};

Nesse caso, o limite de tamanho de solicitação da API é avaliado com base no tamanho após Base64. Ao enviar um arquivo de 10 MB, observe que o corpo JSON se tornará aproximadamente 13,3 MB ou mais.

Anexo de Email (SMTP)

O protocolo SMTP é baseado em texto ASCII, então os anexos são codificados em Base64. O limite de anexos do Gmail é 25 MB, mas este refere-se ao tamanho do arquivo antes da codificação (o Gmail processa a codificação internamente). No entanto, ao enviar diretamente via SMTP, o tamanho após a codificação está sujeito ao limite, portanto cuidado é necessário.

Data URI da tag <code>img</code>

<!-- Base64埋め込み画像 -->
<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAA..." />

Ao incorporar imagens inline em HTML, o arquivo HTML aumenta de tamanho proporcionalmente ao tamanho da imagem em Base64. Geralmente, a incorporação inline de imagens grandes deve ser evitada, pois afeta a velocidade de carregamento da página.

Decodificar Base64 para retornar ao tamanho original

Resumo

• Base64 converte <strong>3 bytes → 4 caracteres</strong>, portanto o tamanho <strong>aumenta aproximadamente 33,3%</strong>
• Com quebras de linha MIME (a cada 76 caracteres) há um aumento ligeiramente maior
• Em APIs que enviam arquivos no corpo JSON, o limite de requisição é determinado pelo tamanho após Base64
• Em formulários HTML com <code>multipart/form-data</code>, a codificação Base64 não é necessária (os dados binários são enviados conforme estão)

Arquivo de teste disponível para usar neste artigo

• → <a href="/ja/files/images/png/" class="text-primary-600 dark:text-primary-400 hover:underline">Lista de arquivos de teste de imagem PNG</a>
• → <a href="/ja/files/pdf/" class="text-primary-600 dark:text-primary-400 hover:underline">Lista de arquivos de teste PDF</a>

Artigos relacionados

• → <a href="/ja/blog/multipart-form-data-overhead/" class="text-primary-600 dark:text-primary-400 hover:underline">Calcular com precisão o overhead de multipart/form-data</a>
• → <a href="/ja/blog/file-format-quick-reference/" class="text-primary-600 dark:text-primary-400 hover:underline">Referência rápida de formato de arquivo para desenvolvedores</a>