Todos os artigos
176 artigos · atualizado semanalmente Veja nossas Ferramentas
Todos os artigos
Tutoriais

O que é Base64: como funciona, para que serve e exemplos

Base64 transforma bytes em texto com 64 caracteres. Veja como funciona passo a passo, por que fica 33% maior, quando usar e por que não é criptografia.

O que é Base64: como funciona, para que serve e exemplos
COVER · Tutoriais

Você abriu o JSON de uma API e encontrou um campo com algo como iVBORw0KGgoAAAANSUhEUgAA... que se estende por dezenas de linhas. Ou colou um token e percebeu que ele termina em ==. A primeira reação de muita gente é "isso está criptografado". Não está. É Base64 — uma codificação, não uma cifra. E entender essa diferença é o que separa quem usa Base64 com segurança de quem coloca uma falsa sensação de proteção no sistema.

Resposta curta: Base64 é uma forma de representar qualquer sequência de bytes (imagem, PDF, chave, texto) usando só 64 caracteres de texto seguros: A–Z, a–z, 0–9, + e /. Serve para transportar dados binários por canais que só aceitam texto — e-mail, JSON, HTML, headers HTTP — ao custo de deixar o dado cerca de 33% maior.

O resto deste guia mostra como o algoritmo funciona passo a passo, onde ele aparece, por que não é criptografia, a variante Base64URL, como codificar e decodificar no JavaScript, no Python e no terminal, e quando não usar. Todos os exemplos de codificação abaixo foram rodados no Node, no Python e no base64 do GNU coreutils.

Como o Base64 funciona, passo a passo

Em vez de trabalhar byte a byte (8 bits), o Base64 agrupa os bits da entrada em blocos de 6. Como 2⁶ = 64, cada bloco de 6 bits vira exatamente um dos 64 caracteres da tabela. Três bytes de entrada (24 bits) viram quatro caracteres de saída (4 × 6 = 24 bits).

Pegue a string Man:

Texto:    M        a        n
Byte:     77       97       110
Binário:  01001101 01100001 01101110
Em 6 bits: 010011  010110   000101   101110
Índice:   19       22       5        46
Base64:   T        W        F        u

Resultado: TWFu. É exatamente o que qualquer biblioteca devolve. O índice vira caractere por esta tabela, definida na RFC 4648:

Índices Caracteres
0–25 A a Z
26–51 a a z
52–61 0 a 9
62 +
63 /
padding =

O que é o = no final

A entrada quase nunca tem um número de bytes múltiplo de 3. Quando sobra um pedaço, o último grupo é completado com bits zero só até fechar o último caractere de 6 bits, e as posições que ficariam vazias no grupo de 4 viram =. A RFC 4648 (§4) define os dois casos:

"Man"   (3 bytes, sobra 0) → TWFu
"Ma"    (2 bytes, sobram 2) → TWE=      3 caracteres + "="
"M"     (1 byte,  sobra 1)  → TQ==      2 caracteres + "=="
"Hello" (5 bytes = 3 + 2)   → SGVsbG8=

Ou seja: sobrou 1 byte → ==; sobraram 2 bytes → =. Não tem nada a ver com criptografia, é só o ajuste de tamanho para a saída ser sempre múltipla de 4.

Para que serve o Base64

Muitos protocolos da internet foram desenhados para texto. O caso clássico é o e-mail: o SMTP nasceu para mensagens de texto de 7 bits, e bytes arbitrários podiam ser alterados ou quebrados no caminho. O MIME resolveu codificando anexos em Base64 (RFC 2045), e é assim até hoje. O mesmo raciocínio vale sempre que um dado binário precisa morar dentro de um formato de texto:

  • Data URIs em HTML e CSS — data:image/png;base64,... embute uma imagem pequena direto no markup, sem uma requisição HTTP extra. Para o caminho de ida, o conversor de imagem para Base64 gera a data URL pronta; para a volta, Base64 para imagem mostra e baixa o arquivo.
  • JSON e APIs REST — JSON não tem tipo binário, então arquivos, hashes e chaves viajam como string Base64. Para arquivos grandes, multipart/form-data é melhor (mais sobre isso abaixo).
  • JWT — header, payload e assinatura são Base64URL, separados por pontos. O payload não é criptografado: qualquer um decodifica e lê.
  • HTTP Basic Authentication — usuario:senha vai em Base64 no header Authorization (RFC 7617). Isso não protege a senha; quem garante o sigilo é o HTTPS.
  • Certificados e chaves PEM — o bloco entre -----BEGIN CERTIFICATE----- e -----END CERTIFICATE----- é o certificado binário (DER) em Base64.
  • Banco de dados — dá para guardar binário em Base64 numa coluna TEXT, mas BYTEA (PostgreSQL) ou BLOB (MySQL) guardam o binário nativo, sem os 33% a mais.

Quando a dúvida é o contrário — "tenho um Base64, consigo salvar como arquivo?" — sim: decodifique para bytes e grave os bytes. O passo a passo para imagem, PDF e outros arquivos está em como converter Base64 em texto, imagem e arquivo.

Por que o Base64 fica 33% maior

Cada 3 bytes viram 4 caracteres, então o tamanho da saída é 4 × ceil(n / 3), onde n é o número de bytes da entrada. Um arquivo de 100 KB (102.400 bytes) vira 136.536 caracteres, cerca de 133 KB. Uma imagem de 1 MB vira ~1,33 MB. Um upload de 500 MB viraria ~667 MB de string na memória.

Em e-mail o overhead é um pouco maior: o MIME limita cada linha a 76 caracteres e insere uma quebra de linha (CRLF) entre elas. O base64 do GNU coreutils imita isso por padrão — quebra a saída a cada 76 caracteres; use base64 -w 0 para uma linha só.

Além do tamanho, uma string Base64 longa é opaca: polui log, quebra diff e não comprime tão bem quanto o binário original. Isso pesa na decisão de embutir ou não.

Base64 vs Base64URL

O Base64 padrão usa + e / como caracteres 62 e 63, e os dois têm significado especial em URLs: / separa segmentos de path, e numa query string no formato application/x-www-form-urlencoded o + é decodificado como espaço. Um Base64 padrão colocado num parâmetro de URL sem percent-encoding chega ao servidor com espaços no lugar dos + e a decodificação falha.

A variante Base64URL (RFC 4648 §5) troca + por - e / por _:

bytes FB FF → Base64:    +/8=
            → Base64URL: -_8    (sem padding)

O padding é opcional na variante URL e frequentemente omitido; o JWT, por exemplo, exige Base64URL sem = (RFC 7515). Por isso um JWT nunca tem +, / ou =. Se você está decidindo entre Base64 e percent-encoding para um valor em URL, o post sobre URL encoding compara os dois.

Base64 não é criptografia

Base64 é totalmente reversível e não usa chave. Não há segredo envolvido:

// Isto NÃO protege a senha. Qualquer pessoa reverte.
const fake = btoa("admin:supersecreta123"); // "YWRtaW46c3VwZXJzZWNyZXRhMTIz"
atob(fake);                                  // "admin:supersecreta123"

A regra: Base64 serve para transporte e representação, não para confidencialidade. Para proteger dados, use criptografia de verdade — simétrica ou assimétrica, conforme o caso. Para senhas, nem isso: use hashing com bcrypt, scrypt ou Argon2. Base64 pode entrar depois, para empacotar o resultado já cifrado em texto — nunca como a camada de proteção.

Base64 não é UTF-8

Outra confusão comum: tratar Base64 como um "encoding de texto" no mesmo nível do UTF-8. UTF-8 mapeia caracteres para bytes; Base64 mapeia bytes para texto ASCII. Para codificar uma string com acento, primeiro ela vira bytes em UTF-8, depois Base64. O btoa do navegador pula essa etapa e trata cada caractere como um byte Latin-1 — o que gera dois bugs diferentes:

btoa("€");     // InvalidCharacterError: fora do Latin-1, nem codifica
btoa("ação");  // "Yefjbw==" — codifica, mas em Latin-1, não UTF-8
// O Base64 de "ação" em UTF-8 é "YcOnw6Nv"

O segundo é o mais traiçoeiro: não dá erro, e o outro lado decodifica como UTF-8 e recebe lixo. Esse degrau anterior ao Base64 é exatamente a armadilha de encoding do UTF-8.

Como codificar e decodificar Base64 em JavaScript, Python e terminal

JavaScript no navegador, com UTF-8 correto:

// Texto → Base64 (UTF-8)
const bytes = new TextEncoder().encode("ação");
const b64 = btoa(String.fromCharCode(...bytes));          // "YcOnw6Nv"

// Base64 → texto (UTF-8)
const volta = Uint8Array.from(atob(b64), c => c.charCodeAt(0));
new TextDecoder().decode(volta);                         // "ação"

Os navegadores atuais têm uma API nativa para isso: Uint8Array.prototype.toBase64() e Uint8Array.fromBase64(), Baseline 2025 (disponível nos principais navegadores desde setembro de 2025), com suporte a Base64URL:

new TextEncoder().encode("ação").toBase64();                          // "YcOnw6Nv"
new TextDecoder().decode(Uint8Array.fromBase64("YcOnw6Nv"));          // "ação"
new Uint8Array([0xfb, 0xff]).toBase64({ alphabet: "base64url", omitPadding: true }); // "-_8"

No Node, testei: a API existe no Node 25 e ainda não no Node 24. No Node, o caminho clássico é Buffer:

Buffer.from("ação").toString("base64");               // "YcOnw6Nv"
Buffer.from("YcOnw6Nv", "base64").toString("utf8");   // "ação"
Buffer.from([0xfb, 0xff]).toString("base64url");      // "-_8"

Python:

import base64

base64.b64encode("ação".encode("utf-8"))           # b'YcOnw6Nv'
base64.b64decode("YcOnw6Nv").decode("utf-8")       # 'ação'
base64.urlsafe_b64encode(bytes([0xFB, 0xFF]))      # b'-_8=' (mantém o padding)

Terminal (GNU coreutils):

printf 'Hello' | base64          # SGVsbG8=
echo 'YcOnw6Nv' | base64 -d      # ação
base64 -w 0 arquivo.pdf          # arquivo inteiro numa linha só

Um detalhe de padding que pega muita gente: o atob do navegador e o Buffer do Node aceitam SGVsbG8 sem o = final, mas o base64 -d do GNU responde invalid input e o Python dá Incorrect padding. Ao receber Base64URL sem padding, complete com = até o tamanho ser múltiplo de 4 antes de decodificar nessas ferramentas. Para inspecionar uma string colada sem escrever código, o decodificador Base64 aceita data URL e Base64URL, e para olhar o conteúdo de um token o JWT decoder separa as três partes.

Quando não usar Base64

  • Arquivo grande. Um upload de vídeo em Base64 dentro de JSON obriga o servidor a ter a string inteira (33% maior) em memória antes de processar. multipart/form-data existe para isso e permite streaming.
  • Canal que já aceita binário. HTTP transporta corpo binário com o Content-Type certo (application/octet-stream, image/png), em qualquer versão do protocolo. WebSocket tem frames binários. gRPC tem o tipo bytes do Protocol Buffers. Se você controla os dois lados e o canal aceita binário, Base64 só adiciona overhead.
  • Imagens grandes em Data URI. Incham o HTML, não ficam em cache separado e atrasam o primeiro render. Data URI vale para ícones de poucos KB.
  • Proteção. Já vimos: não protege nada.
  • Dado que já é texto. Codificar um JSON em Base64 só gasta espaço, a menos que o canal mexa em caracteres especiais.

Para comparar com a outra forma comum de representar bytes como texto, veja Base64 vs hexadecimal: hex é mais legível e dobra o tamanho; Base64 é mais compacto.

Perguntas frequentes

Base64 é criptografia?

Não. Base64 é codificação reversível e sem chave: qualquer pessoa com a string recupera o dado original em um segundo. Criptografia usa uma chave secreta para tornar o dado ilegível sem ela. Confundir as duas é o erro de segurança mais comum com Base64.

Por que strings Base64 terminam em "=" ou "=="?

É padding. A saída é sempre múltipla de 4 caracteres; quando a entrada não é múltipla de 3 bytes, o último grupo é completado com =. Se sobrou 1 byte, ele vira 2 caracteres + ==; se sobraram 2 bytes, viram 3 caracteres + =. Hello (5 bytes) vira SGVsbG8=.

Por que o JWT tem pontos no meio do Base64?

Porque um JWT não é uma única string Base64: são três partes Base64URL separadas por pontos — header.payload.signature. Cada parte é codificada separadamente, sem padding. O header descreve o algoritmo, o payload carrega as claims e a assinatura é calculada sobre os dois primeiros.

Posso guardar senhas em Base64?

Não. Base64 é reversível sem nenhuma informação adicional. Senha se guarda com uma função de hash lenta e com salt — bcrypt, scrypt ou Argon2 —, que não pode ser revertida.

Base64 é uma ferramenta ou um programa?

Nenhum dos dois: é um formato de codificação padronizado (RFC 4648). Qualquer linguagem tem uma função para ele, os sistemas Unix têm o comando base64, e existem ferramentas online que codificam e decodificam no navegador.

Base64 muda a forma do dado, nunca o segredo

Base64 é um tradutor entre o mundo binário e o mundo do texto: 3 bytes viram 4 caracteres, o = fecha o último grupo, e o resultado fica 33% maior. Ele faz sentido quando o canal só fala texto e o dado é pequeno — e-mail, Data URIs, campos binários em JSON, partes de um JWT. Atrapalha quando o arquivo é grande, quando o canal já aceita binário ou quando alguém espera que ele proteja algo. Use Base64URL em URLs, passe por UTF-8 antes de codificar texto e confira o padding na hora de decodificar.


Nota: o conteúdo editorial acabou aqui. O que vem abaixo é uma indicação de ferramenta relacionada ao tema do post.


Ferramenta relacionada

Para codificar texto ou um arquivo inteiro sem escrever código, o codificador Base64 converte texto UTF-8 e arquivos (PDF, ZIP, DOCX) em Base64 ou Base64URL direto no navegador, sem enviar nada para um servidor.

RD
Autor
Rafael Duarte
Desenvolvedor backend com passagem por fintech e SaaS B2B — trabalhou em times que escalaram APIs de zero a milhões de requisições. Carrega cicatrizes de produção suficientes para ter opiniões fortes sobre ferramentas, padrões e decisões de arquitetura. Não é acadêmico: leu a RFC do UUID quando precisou escolher entre v4 e v7 para uma tabela de alta escrita.
Ver perfil