Artigo Build·Desenvolvimento·11 min de leitura

O que é Base64? Como Funciona, Para que Serve e Como Usar

Base64 está em todo lugar — JWT, e-mail, imagens em CSS, HTTP Basic Auth — mas pouca gente entende como funciona. Neste guia você aprende a teoria, vê exemplos em 4 linguagens e descobre quando NÃO usar.

Por Vitor Morais

Fundador do MochaLabz · publicado em 18 de abril de 2026

Encode/Decode Base64 online — sem enviar dados

Texto, URLs e Base64URL. 100% no seu navegador, com suporte a Unicode.

Usar codificador Base64 →

Base64 é uma codificação que representa qualquer dado binário usando apenas 64 caracteres de texto ASCII (A–Z, a–z, 0–9, +, /). É a forma padrão de transportar binário em protocolos que só aceitam texto — e-mail, JSON, JWT, URLs e HTML — e é importante deixar claro desde o início: Base64 não é criptografia. É só uma forma de empacotar bytes em letras.

O que é Base64

Base64 é um esquema de codificação binário-para-texto padronizado pela RFC 4648. Ele representa qualquer sequência de bytes usando apenas 64 caracteres ASCII imprimíveis: letras maiúsculas (A–Z), minúsculas (a–z), dígitos (0–9), e os símbolos + e /. O nome “Base64” vem exatamente desse alfabeto de 64 símbolos.

A ideia é simples: pegar dados binários (uma imagem, um arquivo, uma chave criptográfica) e transformá-los em uma string que pode ser colada em qualquer lugar que aceite texto — um campo JSON, um parâmetro de URL, um corpo de e-mail, um atributo HTML.

Por que Base64 existe

Vários protocolos da internet foram projetados nos anos 70–80, antes de existir padrão para envio de bytes binários. SMTP (e-mail), HTTP headers, JSON e XML assumem que o conteúdo é texto ASCII de 7 bits. Mandar bytes brutos por esses canais quebrava parsers, perdia caracteres de controle e corrompia o conteúdo.

Para resolver isso surgiram codificações de transporte como uuencode, quoted-printable e — a vencedora — Base64, padronizada para uso em e-mail (MIME) na RFC 2045 em 1996. Hoje ela é o padrão de fato para qualquer situação em que você precisa empacotar bytes em texto.

Resumo do problema

Protocolos textuais não conseguem transportar binário sem corromper. Base64 traduz bytes em uma string que sobrevive a qualquer canal que aceita texto plano.

Como o algoritmo funciona passo a passo

O algoritmo Base64 sempre processa os dados em grupos de 3 bytes (24 bits) e produz 4 caracteres Base64 (cada um carregando 6 bits). A razão 24÷6 = 4 é a chave para entender tudo, inclusive o padding e o overhead de tamanho.

Conversão de bytes em grupos de 6 bits

Vamos codificar a string “Man” passo a passo:

Texto:    M        a        n
ASCII:    77       97       110
Binário:  01001101 01100001 01101110

Concatena:  010011010110000101101110   (24 bits)

Reagrupa em 6 bits:
  010011  010110  000101  101110

Cada grupo vira um índice (0–63):
   19      22      5       46

Procura no alfabeto Base64:
   T       W       F       u

Resultado: "TWFu"

O alfabeto Base64 (A–Z, a–z, 0–9, +, /)

A tabela é fixa e descrita pela RFC 4648. Cada índice de 0 a 63 mapeia para um caractere específico:

Alfabeto Base64 padrão (RFC 4648, seção 4)
Critério	Índice	Caractere
0–25	0–25	A B C D … X Y Z
26–51	26–51	a b c d … x y z
52–61	52–61	0 1 2 3 4 5 6 7 8 9
62	62	+
63	63	/

Padding com o caractere =

Como o algoritmo precisa de blocos completos de 24 bits, quando o input não é múltiplo de 3 bytes, o último bloco é completado com zeros e o resultado recebe um ou dois =:

"Man"  → 3 bytes  → "TWFu"   (sem padding)
"Ma"   → 2 bytes  → "TWE="   (1 byte faltando → 1 padding)
"M"    → 1 byte   → "TQ=="   (2 bytes faltando → 2 paddings)

O padding torna a saída sempre múltipla de 4 caracteres, o que facilita parsers a saber exatamente onde uma string Base64 termina. Algumas variantes — como Base64URL no JWT — abrem mão do padding para economizar bytes.

Onde Base64 aparece no dia a dia

Mesmo quem nunca codificou Base64 manualmente já se deparou com ele. Os principais lugares são:

E-mail (MIME)

Anexos de e-mail (PDFs, imagens, planilhas) são codificados em Base64 dentro do corpo do e-mail. Quando você anexa um arquivo de 1 MB, ele chega como ~1,33 MB de texto Base64 dentro da mensagem MIME.

JSON Web Tokens (JWT)

Um JWT é composto por três partes separadas por pontos: header.payload.signature. Cada parte é um JSON codificado em Base64URL. Isso permite que o token inteiro seja transmitido em headers HTTP, cookies e URLs sem escapar caracteres.

eyJhbGciOiJIUzI1NiJ9.eyJzdWIiOiIxMjMifQ.fHgB...
   └── header ──┘ └─── payload ───┘ └─ sig ─┘

Decodificando o header:
  eyJhbGciOiJIUzI1NiJ9  →  {"alg":"HS256"}

Imagens em HTML e CSS (Data URLs)

Você pode embutir uma imagem direto no HTML/CSS, eliminando uma requisição HTTP, com data: URL:

<img src="data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAA..." />

/* CSS background */
.icon { background-image: url("data:image/svg+xml;base64,PHN2..."); }

HTTP Basic Auth

A autenticação HTTP mais simples envia usuario:senha codificado em Base64 dentro do header Authorization. Esse mecanismo é antigo e inseguro sem HTTPS, porque Base64 não esconde nada — só empacota.

# "alice:s3cret" em Base64
Authorization: Basic YWxpY2U6czNjcmV0

Base64 padrão vs Base64URL

A RFC 4648 define duas variantes principais. A diferença está em dois caracteres do alfabeto e na obrigatoriedade do padding:

Diferenças entre Base64 padrão e Base64URL
Critério	Base64 padrão	Base64URL
Caractere índice 62	`+`	`-`
Caractere índice 63	`/`	`_`
Padding (=)	Obrigatório	Geralmente omitido
Seguro em URL?	Não — + e / precisam ser escapados	Sim — pode ir direto
Onde aparece	MIME / e-mail / Basic Auth	JWT, OAuth, identificadores em URL

Como saber qual variante é qual

Se uma string Base64 contém - ou _, é Base64URL. Se contém +, / ou termina em =, é Base64 padrão. Decodificadores modernos geralmente aceitam as duas.

Como codificar e decodificar Base64

Praticamente toda linguagem moderna tem Base64 na biblioteca padrão. Aqui estão exemplos em quatro stacks comuns.

JavaScript (browser + Node.js)

// --- Browser (ASCII puro) ---
btoa('Hello');              // "SGVsbG8="
atob('SGVsbG8=');           // "Hello"

// --- Browser (Unicode-safe) ---
function encodeUtf8(text) {
  const bytes = new TextEncoder().encode(text);
  return btoa(String.fromCharCode(...bytes));
}
function decodeUtf8(b64) {
  const binary = atob(b64);
  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
  return new TextDecoder().decode(bytes);
}

encodeUtf8('olá, mundo! 🌍');  // funciona com acentos e emoji

// --- Base64URL (JWT-friendly) ---
function toBase64Url(b64) {
  return b64.replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
}

// --- Node.js ---
Buffer.from('Hello').toString('base64');                  // "SGVsbG8="
Buffer.from('SGVsbG8=', 'base64').toString();             // "Hello"
Buffer.from('Hello').toString('base64url');               // "SGVsbG8" (sem =)

Python

import base64

# Codifica
base64.b64encode(b'Hello')                  # b'SGVsbG8='
base64.b64encode('olá'.encode('utf-8'))     # b'b2zDoQ=='

# Decodifica
base64.b64decode(b'SGVsbG8=')               # b'Hello'

# Base64URL (sem padding, - e _)
base64.urlsafe_b64encode(b'Hello').rstrip(b'=')   # b'SGVsbG8'

# Codifica um arquivo inteiro
with open('foto.jpg', 'rb') as f:
    encoded = base64.b64encode(f.read())

Go

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {
    data := []byte("Hello")

    // Padrão
    enc := base64.StdEncoding.EncodeToString(data)
    fmt.Println(enc)            // SGVsbG8=

    // URL-safe
    encURL := base64.URLEncoding.EncodeToString(data)
    fmt.Println(encURL)         // SGVsbG8=

    // URL-safe sem padding
    encRaw := base64.RawURLEncoding.EncodeToString(data)
    fmt.Println(encRaw)         // SGVsbG8

    dec, _ := base64.StdEncoding.DecodeString(enc)
    fmt.Println(string(dec))    // Hello
}

Bash / linha de comando

# Codifica
echo -n "Hello" | base64
# SGVsbG8=

# Decodifica
echo "SGVsbG8=" | base64 -d
# Hello

# Codifica um arquivo
base64 foto.jpg > foto.jpg.b64

# Decodifica de volta
base64 -d foto.jpg.b64 > foto.jpg

Base64 NÃO é criptografia (e por quê)

Esse é o erro mais cometido com Base64. Como a string codificada parece aleatória, é tentador pensar que ela “esconde” o conteúdo. Não esconde. Qualquer pessoa com 5 segundos e um decodificador online consegue ler o que tem dentro.

Nunca, em hipótese alguma

Não “cifre” senhas com Base64. Use bcrypt ou Argon2.
Não esconda chaves de API com Base64.
Não confie no payload de um JWT só porque está em Base64URL — o conteúdo é totalmente legível, só a assinatura garante que ninguém o alterou.
Não use Base64 como substituto de TLS/HTTPS.

Base64 é codificação (transformação reversível e pública), não cifra (depende de uma chave secreta). Se o seu objetivo é proteger algo, escolha o algoritmo certo — bcrypt ou Argon2 para senhas, AES-GCM para dados, RSA/Ed25519 para assinatura.

O overhead de 33%: quando Base64 dói

Como cada 3 bytes do binário viram 4 caracteres Base64, o tamanho aumenta em 4/3 ≈ 33,3%. Em pequenas strings isso é irrelevante; em arquivos grandes pode ser um problema sério:

Crescimento de tamanho ao codificar em Base64
Critério	Original	Em Base64	Acréscimo
100 B	100 B	≈ 136 B	+36%
1 KB	1 024 B	≈ 1 368 B	+33,5%
1 MB	1 MB	≈ 1,37 MB	+33,3%
100 MB	100 MB	≈ 137 MB	+33,3%

Boas práticas para mitigar o overhead:

Comprima antes: gzip + Base64 fica menor que Base64 puro para texto repetitivo.
Use streaming: bibliotecas modernas codificam em chunks, evitando carregar 100 MB em RAM.
Prefira binário direto: se o canal aceita (HTTP/2, gRPC, WebSocket), envie bytes brutos em vez de Base64.
Considere Data URLs com cuidado: imagens grandes inline aumentam o HTML em ~33% e bloqueiam parsing.

Checklist: quando usar Base64

Use Base64 quando:

O canal só aceita texto (e-mail, JSON, atributo HTML, parâmetro de URL).
Você precisa empacotar binário pequeno (chave criptográfica, hash, ID compacto).
Está implementando JWT, Basic Auth, OAuth ou outro padrão que já exige Base64URL.
Quer embutir um SVG ou ícone pequeno em CSS sem requisição HTTP extra.

Evite Base64 quando:

O dado é grande (> 100 KB) e há canal binário disponível.
Você quer “esconder” alguma coisa — isso é cifra, não codificação.
Performance e largura de banda são críticas (cada 3 bytes vira 4 — sempre).

Perguntas frequentes

O que significa Base64 em termos simples?+

Base64 é uma forma de escrever dados binários (imagens, arquivos, chaves, qualquer sequência de bytes) usando apenas 64 caracteres de texto comum: A–Z, a–z, 0–9, + e /. É como traduzir bytes para um "alfabeto" que cabe em qualquer protocolo que aceita texto (e-mail, URL, JSON, HTML).

Base64 é criptografia? É seguro guardar senhas em Base64?+

Não. Base64 é uma codificação reversível, não uma cifra. Qualquer pessoa que vê uma string Base64 consegue decodificar em milissegundos sem chave nenhuma. Para proteger dados sensíveis, use criptografia (AES, RSA) e para senhas, use hashing com bcrypt ou Argon2.

Por que Base64 aumenta o tamanho dos dados em ~33%?+

Cada 3 bytes do binário original (24 bits) viram 4 caracteres Base64 (cada um carrega 6 bits úteis). A razão 4/3 é exatamente +33,3%. Por isso Base64 é ótimo para transportar binário em protocolos textuais, mas evite para arquivos grandes em produção — o overhead de banda é real.

Qual a diferença entre Base64 e Base64URL?+

Base64URL substitui os caracteres + e / por - e _, e geralmente omite o padding =. Isso evita problemas em URLs e nomes de arquivo, onde + e / têm significado especial. O JWT usa Base64URL exatamente por esse motivo.

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

Base64 trabalha em blocos de 3 bytes. Quando os bytes do input não são múltiplos de 3, o algoritmo completa o bloco e adiciona = (1 byte faltando) ou == (2 bytes faltando) para indicar o tamanho original. Algumas variantes (como Base64URL) omitem esse padding.

Posso converter qualquer arquivo para Base64?+

Sim. Como Base64 trabalha sobre bytes brutos, qualquer arquivo (imagem PNG, PDF, vídeo, ZIP) pode ser codificado. O resultado será uma string ~33% maior que o arquivo original, formada apenas pelos 64 caracteres do alfabeto.

Como Base64 lida com caracteres acentuados e Unicode?+

Base64 codifica bytes, não caracteres. Para acentos e emojis, você precisa primeiro converter o texto para UTF-8 (gerando os bytes corretos) e depois aplicar Base64. No JavaScript do browser, o caminho seguro é btoa(unescape(encodeURIComponent(texto))), ou usar TextEncoder em código moderno.

Existe alguma alternativa mais eficiente que Base64?+

Para alfabetos maiores (URL-safe e mais compactos), existem Base85 (~25% overhead) e Base122 (~14%), mas o suporte é raríssimo. Em protocolos modernos como HTTP/2 e gRPC, prefira transferir bytes diretamente em vez de codificar — Base64 só é necessário quando o canal exige texto.

#base64#base64url#codificação#javascript#python#go#jwt#binário#ascii#data url

Continue lendo

⚖️ ComparativoBuild13 min de leitura

bcrypt vs Argon2 vs scrypt vs PBKDF2: Qual Usar para Senhas (2026)

Comparativo técnico OWASP-aligned entre bcrypt, Argon2id, scrypt e PBKDF2 para hashing de senhas em 2026. Recomendações, parâmetros corretos por hardware, exemplos em Node.js/Python/Go/PHP e estratégia de migração.

18 de abril de 2026

Ver comparativo

#bcrypt#argon2#argon2id

DesenvolvimentoBuild12 min de leitura

O que é JSON? Guia Completo com Exemplos em 6 Linguagens

JSON é o formato de dados mais usado na web. Aprenda a sintaxe, os 6 tipos de dados, parsing em JavaScript, Python, Go, Java, PHP e Ruby, JSON5/JSONC, erros comuns e boas práticas.

18 de abril de 2026

Ler artigo

#json#javascript#python

DesenvolvimentoBuild13 min de leitura

Base64 para Imagens em HTML e CSS: Quando Vale (e Quando Evita) — 2026

Embutir imagens como Base64 (Data URLs) elimina requisições HTTP mas aumenta tamanho do HTML/CSS e quebra cache. Análise completa, casos de uso reais (LQIP, ícones SVG, e-mail), benchmarks e alternativas modernas.

18 de abril de 2026

Ler artigo

#base64#imagens#css

DesenvolvimentoBuild13 min de leitura

JWT e Base64URL: Como Funciona a Autenticação com JSON Web Tokens (2026)

Anatomia completa do JWT, papel do Base64URL, decodificação manual em qualquer linguagem, escolha entre HS256/RS256/ES256, claims padrão, boas práticas de armazenamento e os 8 erros que destroem a segurança.

18 de abril de 2026

Ler artigo

#jwt#base64url#json web token