Base64 — Codificar e Decodificar 2026

Converta texto para Base64 e vice-versa. Suporte a texto, URL-safe Base64 e arquivos binários.

Texto / Dados

Base64

URL-safe Base64 (+ → - e / → _)

O que é Base64?

Base64 codifica dados binários em 64 caracteres ASCII (A-Z, a-z, 0-9, +, /). É 33% maior que o original e amplamente usado em:

E-mails (MIME) e arquivos anexos
Data URLs em HTML/CSS (data:image/png;base64,...)
Tokens JWT e autenticação HTTP Basic
APIs REST que trafegam binários

🔡 O que é Base64?

Base64 é um esquema de codificação binário-para-texto que representa dados binários usando apenas 64 caracteres ASCII imprimíveis: letras maiúsculas (A–Z), minúsculas (a–z), dígitos (0–9), mais os símbolos + e /, com = como padding.

O nome vem da base matemática: assim como base 10 usa 10 dígitos (0–9) e base 16 usa 16 (0–9, A–F), Base64 usa 64 símbolos diferentes — o suficiente para representar 6 bits por caractere. O resultado é um texto que pode ser transmitido por qualquer canal que suporte ASCII, mesmo que o dado original seja binário puro (imagem, PDF, executável).

📌

Base64 não é criptografia. É apenas uma codificação — qualquer pessoa pode decodificá-la instantaneamente. Não use Base64 para "esconder" dados sensíveis. Para segurança, use criptografia real (AES, RSA, bcrypt).

⚙️ Como Base64 Funciona por Dentro

O algoritmo converte 3 bytes (24 bits) de entrada em 4 caracteres Base64 (24 bits = 4 × 6 bits). Isso explica o overhead de ~33%: cada 3 bytes viram 4 caracteres.

Exemplo: codificando "Man"

Texto original

→

M a n

ASCII decimal

→

77 97 110

Binário (8 bits)

→

01001101 01100001 01101110

Grupos de 6 bits

→

010011 010110 000101 101110

Valor decimal

→

19 22 5 46

Caractere Base64

→

T W F u → "TWFu"

Quando o input não é múltiplo de 3 bytes, o algoritmo adiciona padding com =: 1 byte restante → dois caracteres + ==; 2 bytes restantes → três caracteres + =.

🔤 O Alfabeto Base64

Valor (0–63)	Char	Valor	Char	Valor	Char	Valor	Char
0	A	16	Q	32	g	48	w
1	B	17	R	33	h	49	x
2	C	18	S	34	i	50	y
3	D	19	T	35	j	51	z
4	E	20	U	36	k	52	0
5	F	21	V	37	l	53	1
6	G	22	W	38	m	54	2
7	H	23	X	39	n	55	3
8	I	24	Y	40	o	56	4
9	J	25	Z	41	p	57	5
10	K	26	a	42	q	58	6
11	L	27	b	43	r	59	7
12	M	28	c	44	s	60	8
13	N	29	d	45	t	61	9
14	O	30	e	46	u	62	+
15	P	31	f	47	v	63	/

🛠️ Onde Base64 é Usado na Prática

📧

E-mail (MIME)

Anexos de e-mail são codificados em Base64 pelo protocolo MIME. Imagens, PDFs e executáveis trafegam como texto puro nos headers SMTP.

🖼️

Data URLs

Imagens embutidas diretamente no HTML/CSS: src="data:image/png;base64,...". Elimina requisições HTTP extras para assets pequenos.

🔑

JWT Tokens

Os três segmentos de um JWT (header, payload, signature) são separados por pontos e cada um é Base64URL encoded — variante sem +, / ou =.

🔒

HTTP Basic Auth

O header Authorization: Basic transmite usuário:senha codificados em Base64. Fácil de decodificar — sempre use com HTTPS.

🗝️

Chaves e Certificados

Chaves PEM (RSA, TLS/SSL) são certificados DER binários codificados em Base64 entre tags -----BEGIN...-----.

🌐

APIs REST

APIs que precisam trafegar binários (imagens, PDFs) em JSON usam Base64 para converter o binário em campo de texto compatível com o formato.

💻 Base64 em Diferentes Linguagens

JavaScript

// Browser
const encoded = btoa("Olá mundo");           // → "T2zDoSBtdW5kbw=="
const decoded = atob("T2zDoSBtdW5kbw==");      // → "Olá mundo"

// Node.js — Buffers
const enc = Buffer.from("Olá mundo").toString("base64");
const dec = Buffer.from(enc, "base64").toString("utf8");

// URL-safe (sem +, /, =)
const urlSafe = enc.replace(/\+/g, "-").replace(/\//g, "_").replace(/=/g, "");

Python

import base64

# Codificar
encoded = base64.b64encode(b"Ola mundo").decode("utf-8")   # → "T2xhIG11bmRv"
# Decodificar
decoded = base64.b64decode("T2xhIG11bmRv").decode("utf-8") # → "Ola mundo"

# URL-safe
enc_url = base64.urlsafe_b64encode(b"data")
dec_url = base64.urlsafe_b64decode(enc_url)

PHP

// Codificar
$encoded = base64_encode("Olá mundo");      // "T2zDoSBtdW5kbw=="
// Decodificar
$decoded = base64_decode("T2zDoSBtdW5kbw==");

// URL-safe manual
$urlSafe = str_replace(['+', '/', '='], ['-', '_', ''], $encoded);

Java

import java.util.Base64;

// Codificar
String encoded = Base64.getEncoder().encodeToString("Olá".getBytes());
// Decodificar
byte[] decoded = Base64.getDecoder().decode(encoded);

// URL-safe
String encUrl = Base64.getUrlEncoder().withoutPadding().encodeToString("data".getBytes());

C# / .NET

using System;

// Codificar
string encoded = Convert.ToBase64String(System.Text.Encoding.UTF8.GetBytes("Olá"));
// Decodificar
string decoded = System.Text.Encoding.UTF8.GetString(Convert.FromBase64String(encoded));

import "encoding/base64"

// Codificar
encoded := base64.StdEncoding.EncodeToString([]byte("Olá mundo"))
// Decodificar
decoded, err := base64.StdEncoding.DecodeString(encoded)

// URL-safe
encUrl := base64.URLEncoding.EncodeToString([]byte("data"))

Bash / CLI

# Codificar
echo -n "Olá mundo" | base64
# Decodificar
echo "T2zDoSBtdW5kbw==" | base64 --decode

# Codificar arquivo
base64 arquivo.png > arquivo.b64
# Decodificar arquivo
base64 --decode arquivo.b64 > arquivo_restaurado.png

🔀 Base64 Padrão vs Base64URL

O Base64 padrão usa + e / como 62° e 63° caracteres. Esses símbolos têm significado especial em URLs — causando bugs quando Base64 aparece em query strings, paths ou headers HTTP. O Base64URL (RFC 4648 §5) resolve isso substituindo os caracteres problemáticos:

Aspecto	Base64 Padrão (RFC 4648 §4)	Base64URL (RFC 4648 §5)
Caractere 62	+ (plus)	- (hífen)
Caractere 63	/ (barra)	_ (underscore)
Padding `=`	Presente	Opcional (geralmente omitido)
Safe em URLs	Não — precisa de %2B e %2F	Sim — todos os chars são URL-safe
Safe em nomes de arquivo	Não — / é separador de path	Sim
Usado em	MIME, e-mail, Data URLs	JWT, OAuth tokens, URLs, nomes de arquivo

🐛 Problemas Comuns e Como Resolver

❌

Erro: "Invalid character" ou "InvalidCharacterError" no browser

A função btoa() do browser aceita apenas Latin-1 (ISO 8859-1). Para strings com caracteres Unicode (acentos, emoji), converta primeiro para UTF-8:

JS — Unicode fix

// ERRADO — falha com acentos
btoa("Olá"); // ❌ InvalidCharacterError

// CORRETO — encode para UTF-8 primeiro
function b64EncodeUnicode(str) {
  return btoa(encodeURIComponent(str).replace(
    /%([0-9A-F]{2})/g,
    (_, p1) => String.fromCharCode('0x' + p1)
  ));
}
b64EncodeUnicode("Olá"); // ✅ "T2zDoQ=="

⚠️

Padding incorreto — "Incorrect padding"

Base64URL frequentemente omite o = de padding. Ao decodificar, restaure o padding manualmente adicionando = até que o comprimento da string seja múltiplo de 4.

JS — Padding fix

function decodeBase64URL(str) {
  str = str.replace(/-/g, '+').replace(/_/g, '/');
  while (str.length % 4) str += '='; // restaura padding
  return atob(str);
}

💡

Performance: não use Base64 para arquivos grandes. O overhead de ~33% e o custo de CPU para codificar/decodificar tornam Base64 inadequado para arquivos acima de alguns MB. Para uploads de arquivos em APIs REST, prefira multipart/form-data ou upload direto para storage (S3, GCS) com pre-signed URLs.

❓ Perguntas Frequentes sobre Base64

Porque o algoritmo converte 3 bytes (24 bits) em 4 caracteres ASCII (4 bytes). A razão é simples: cada caractere Base64 representa 6 bits, então são necessários 4 × 6 = 24 bits para representar os mesmos 24 bits originais — mas como cada caractere ASCII ocupa 1 byte (8 bits), o resultado final tem 4 bytes onde antes havia 3. Isso representa um aumento de 33,3% no tamanho. Na prática, o overhead pode ser um pouco maior se você incluir os caracteres de nova linha que alguns encoders inserem a cada 76 caracteres (padrão MIME).

Não — Base64 não oferece nenhuma segurança. É uma codificação reversível sem chave, que qualquer pessoa pode decodificar em milissegundos. É comum encontrar senhas e tokens "escondidos" em Base64 em código-fonte ou configurações — isso é considerado uma vulnerabilidade de segurança séria. Para proteger senhas use bcrypt, argon2 ou PBKDF2. Para criptografar dados use AES-256-GCM ou ChaCha20-Poly1305.

Encoding (codificação): transformação reversível de formato. Base64, URL encoding, UTF-8 são encodings. Sem chave, qualquer um pode reverter.
Encryption (criptografia): transformação reversível com chave secreta. AES, RSA. Só quem tem a chave consegue reverter.
Hashing: transformação irreversível (one-way). SHA-256, bcrypt, MD5. Não dá para "decodificar" — serve para verificar integridade e armazenar senhas.

Base64 é encoding — não confunda com segurança.

Sinais de que um texto pode ser Base64:

Contém apenas A-Z, a-z, 0-9, +, / e possivelmente = no final
O comprimento é múltiplo de 4 (ou seria com padding adicionado)
Termina com = ou == (padding)
Parece "aleatório" sem padrão de linguagem natural

Regex para detectar Base64 padrão: /^[A-Za-z0-9+/]*={0,2}$/. Importante: nem todo texto que passa nesse regex é necessariamente Base64 — pode ser coincidência de caracteres.

Sim, mas com cuidado. É uma prática válida para imagens pequenas (thumbnails, ícones, avatars — geralmente abaixo de 100KB). Para imagens maiores:

O payload JSON fica ~33% maior
O parsing de JSON com campos Base64 grandes é lento
Muitos servidores têm limite de tamanho de request body

A alternativa recomendada para imagens grandes é multipart/form-data ou upload direto para storage com URL de retorno. Serviços como AWS S3 e Cloudflare R2 oferecem pre-signed URLs que permitem upload direto do cliente, sem passar pelo servidor da aplicação.

Data URLs permitem embutir arquivos diretamente em HTML/CSS sem request HTTP extra. O formato é:

data:[mediatype];base64,[dados]

Imagem em HTML: <img src="data:image/png;base64,iVBOR...">
Fonte em CSS: src: url("data:font/woff2;base64,...")
PDF em iframe: <iframe src="data:application/pdf;base64,...">

Útil para eliminar requests em assets pequenos e críticos (logo acima do fold, ícones SVG). Para assets maiores, o tradeoff é negativo — aumenta o tamanho do HTML e impossibilita cache do browser para o asset.

Um JWT tem o formato header.payload.signature, onde cada parte é Base64URL encoded. Para ver o payload:


            const [header, payload, sig] = token.split('.');

            const data = JSON.parse(atob(payload.replace(/-/g,'+').replace(/_/g,'/')));

Lembre-se: decodificar o payload de um JWT não valida a assinatura. Para verificar se o token é legítimo, você precisa da chave secreta ou pública. Nunca confie apenas no payload decodificado sem validar a assinatura no servidor.

📌 Resumo para Devs

1️⃣

3 bytes → 4 chars. Sempre +33% de tamanho. Leve para dados pequenos, custoso para grandes volumes.

2️⃣

Não é segurança — é formato. Base64 é reversível sem chave. Nunca use para "esconder" dados sensíveis.

3️⃣

URLs e JWT precisam de Base64URL. Troque +→-, /→_ e remova o = de padding para uso em URLs e tokens.

4️⃣

Unicode no browser: btoa() só aceita Latin-1. Para acentos e emoji, encode para UTF-8 antes de chamar btoa().

5️⃣

Arquivo grande? Use multipart ou storage direto. Base64 em JSON só faz sentido para assets pequenos (<100KB). Acima disso, prefira multipart/form-data ou pre-signed URLs.

Veja também

🔗URL Encode 📋JSON Formatter 🔑UUID 🕒Timestamp ⇄YAML → JSON

Valor (0–63)	Char	Valor	Char	Valor	Char	Valor	Char
0	A	16	Q	32	g	48	w
1	B	17	R	33	h	49	x
2	C	18	S	34	i	50	y
3	D	19	T	35	j	51	z
4	E	20	U	36	k	52	0
5	F	21	V	37	l	53	1
6	G	22	W	38	m	54	2
7	H	23	X	39	n	55	3
8	I	24	Y	40	o	56	4
9	J	25	Z	41	p	57	5
10	K	26	a	42	q	58	6
11	L	27	b	43	r	59	7
12	M	28	c	44	s	60	8
13	N	29	d	45	t	61	9
14	O	30	e	46	u	62	+
15	P	31	f	47	v	63	/

Valor (0–63)	Char	Valor	Char	Valor	Char	Valor	Char
0	A	16	Q	32	g	48	w
1	B	17	R	33	h	49	x
2	C	18	S	34	i	50	y
3	D	19	T	35	j	51	z
4	E	20	U	36	k	52	0
5	F	21	V	37	l	53	1
6	G	22	W	38	m	54	2
7	H	23	X	39	n	55	3
8	I	24	Y	40	o	56	4
9	J	25	Z	41	p	57	5
10	K	26	a	42	q	58	6
11	L	27	b	43	r	59	7
12	M	28	c	44	s	60	8
13	N	29	d	45	t	61	9
14	O	30	e	46	u	62	+
15	P	31	f	47	v	63	/

Valor (0–63)	Char	Valor	Char	Valor	Char	Valor	Char
0	A	16	Q	32	g	48	w
1	B	17	R	33	h	49	x
2	C	18	S	34	i	50	y
3	D	19	T	35	j	51	z
4	E	20	U	36	k	52	0
5	F	21	V	37	l	53	1
6	G	22	W	38	m	54	2
7	H	23	X	39	n	55	3
8	I	24	Y	40	o	56	4
9	J	25	Z	41	p	57	5
10	K	26	a	42	q	58	6
11	L	27	b	43	r	59	7
12	M	28	c	44	s	60	8
13	N	29	d	45	t	61	9
14	O	30	e	46	u	62	+
15	P	31	f	47	v	63	/