> base64 encoder | texto | arquivo <

Digite ou cole seu texto na área ENTRADA acima. A codificação automática está ativada por padrão — o resultado Base64 aparece na caixa SAÍDA enquanto você digita. Clique em [ENCODE] ou pressione Ctrl/Cmd + Enter para acionar a codificação manualmente. Ative --url-safe ou --no-padding dependendo de onde o Base64 será usado (JWT, OAuth, URLs → ambos ativados). Tudo é executado localmente no seu navegador: sem uploads, sem logs, sem requisições de rede vinculadas à sua entrada.

Clique no botão [upload file] abaixo da área de entrada e escolha um arquivo de até 100 MB. O codificador o lê com FileReader.readAsArrayBuffer, transmite os bytes por meio de btoa em blocos de 32 KB (para que arquivos grandes não travem o navegador) e escreve o Base64 completo na caixa SAÍDA. Para arquivos maiores, use um codificador de linha de comando: base64 < input.bin > output.txt (macOS/Linux) ou PowerShell: [Convert]::ToBase64String([IO.File]::ReadAllBytes('input.bin')).

Se você quiser o Base64 formatado como uma Data URI (por exemplo, data:image/png;base64,...), anteponha o tipo MIME e ;base64, à saída, ou use nossa ferramenta dedicada Imagem para Base64, que produz Data URIs prontas para colar para PNG, JPG, GIF, WebP e SVG.

Todas as três são definidas na RFC 4648:

• Base64 padrão (§4) usa o alfabeto A-Z a-z 0-9 + / com preenchimento =. O comprimento da saída é sempre múltiplo de 4. Seguro para MIME, HTTP Basic Auth e valores de string JSON.

• Base64 seguro para URL (§5) substitui + por - e / por _. Necessário quando o Base64 é colocado em caminhos de URL, parâmetros de consulta, nomes de arquivo ou segmentos JWT — os caracteres padrão +/ precisariam, caso contrário, de codificação percentual.

• Sem preenchimento (tanto §4 quanto §5, base64url sem preenchimento) remove os caracteres = finais. O comprimento não é mais múltiplo de 4, mas os decodificadores podem calcular o comprimento original a partir do resto módulo 4. Usado por JWT (base64url conforme a RFC 7515), WebAuthn e algumas implementações CBOR/COSE.

Os decodificadores precisam saber qual variante esperar — nosso Decodificador Base64 detecta automaticamente todas as três.

Toda linguagem e runtime importante vem com codificação Base64. Trechos prontos para copiar e colar:

JavaScript (browser):
btoa('Hello') // SGVsbG8=
// Para UTF-8:
btoa(String.fromCharCode(...new TextEncoder().encode(s))) // seguro para UTF-8

Node.js:
Buffer.from('Hello', 'utf-8').toString('base64') // SGVsbG8=
Buffer.from(bytes).toString('base64url') // seguro para URL, sem preenchimento

Python:
import base64
base64.b64encode(b'Hello').decode() # SGVsbG8=
base64.urlsafe_b64encode(b'Hello').decode().rstrip('=') # seguro para URL sem preenchimento

PHP: base64_encode('Hello')
Ruby: Base64.strict_encode64('Hello') / Base64.urlsafe_encode64('Hello')
Go: base64.StdEncoding.EncodeToString([]byte("Hello")) / base64.URLEncoding.EncodeToString(...) / base64.RawURLEncoding.EncodeToString(...) (sem preenchimento)
Java: Base64.getEncoder().encodeToString("Hello".getBytes(StandardCharsets.UTF_8))
C#: Convert.ToBase64String(Encoding.UTF8.GetBytes("Hello"))
Rust: base64::engine::general_purpose::STANDARD.encode("Hello")

Shell (macOS/Linux): echo -n 'Hello' | base64 → SGVsbG8=. Use base64 -w 0 no Linux para suprimir a quebra de linha em 76 colunas.

A saída Base64 é ~33% maior que a entrada: cada 3 bytes de entrada tornam-se 4 caracteres de saída. Fórmula exata: ceil(n / 3) × 4 incluindo o preenchimento, ou ceil(n × 4 / 3) sem. Além de alguns bytes a mais de sobrecarga se você quebrar linhas em 76 colunas (MIME) ou 64 colunas (PEM).

Exemplos:
• 1 KB binário → ~1,37 KB Base64
• 100 KB imagem → ~137 KB Data URI
• 1 MB PDF → ~1,37 MB Base64 em JSON

Quando evitar o Base64:
• Transferências de arquivos grandes: uma imagem de 10 MB incorporada como Base64 em HTML torna-se 13,7 MB de texto analisado, bloqueia a thread principal e não pode ser armazenada em cache separadamente. Prefira <img src="/assets/photo.png">.
• APIs críticas em desempenho: um payload Base64 de 500 KB em JSON é analisado ~2-3× mais lentamente que um endpoint binário equivalente.
• Como medida de segurança: o Base64 não é criptografia — qualquer um pode decodificá-lo. Use AES-GCM ou similar para confidencialidade.
• BLOBs de banco de dados: armazene bytes brutos como BLOB/BYTEA, não como texto Base64, para economizar 33% de armazenamento e evitar ciclos de codificação/decodificação.

JWT (RFC 7515) e OAuth PKCE (RFC 7636) usam ambos Base64 seguro para URL sem preenchimento, frequentemente chamado de base64url. Para produzi-lo nesta ferramenta: ative as caixas de seleção --url-safe e --no-padding, depois codifique seu texto.

Equivalentes programáticos:
• JavaScript: btoa(s).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '')
• Node.js: Buffer.from(s).toString('base64url')
• Python: base64.urlsafe_b64encode(s.encode()).decode().rstrip('=')
• Go: base64.RawURLEncoding.EncodeToString([]byte(s))
• Java: Base64.getUrlEncoder().withoutPadding().encodeToString(bytes)

Campos JWT comuns que precisam de base64url: os três segmentos separados por ponto (cabeçalho, payload, assinatura), OAuth PKCE code_verifier/code_challenge, desafios WebAuthn, chaves Web Push p256dh/auth e os parâmetros Request.state do Google.

Um bug comum é enviar um JWT com Base64 padrão (+/) — as APIs o rejeitam como malformado porque o + é decodificado de URL para um espaço durante o trânsito.

Sim, com uma ressalva. Este codificador produz a parte Base64 de uma Data URI — a parte após ;base64,. Para construir uma Data URI completa, anteponha:

data:<mime-type>;base64,<encoded-output>

Tipos MIME comuns:
• data:image/png;base64,... — imagem PNG
• data:image/jpeg;base64,... — imagem JPEG
• data:image/svg+xml;base64,... — SVG (ou use data:image/svg+xml;utf8, sem Base64 — geralmente menor)
• data:application/pdf;base64,... — arquivo PDF
• data:application/font-woff2;base64,... — incorporação de fonte
• data:text/plain;charset=utf-8;base64,... — texto encapsulado em Base64

Para imagens e SVGs, a ferramenta Imagem para Base64 emite a Data URI completa pronta para colar em CSS background-image, inline <img src="..."> ou tags <object data="...">.

Aviso de tamanho: Data URIs acima de 20-30 KB prejudicam o LCP (Largest Contentful Paint) porque o navegador não consegue pré-carregá-las — mantenha imagens Base64 inline pequenas e prefira <img> regular com loading="lazy" para ativos maiores.

Sim — nada sai do seu navegador. O codificador é executado inteiramente em JavaScript usando as APIs nativas btoa(), TextEncoder e FileReader. Não há chamadas de rede sobre o conteúdo da entrada, sem telemetria, sem logging, sem análises de terceiros sobre o que você codifica. Você pode abrir a aba Network no DevTools enquanto codifica e observar zero requisições relacionadas.

No entanto, o Base64 não é criptografia — é uma codificação reversível, e qualquer um com a saída pode decodificá-la. Portanto:
• Não cole segredos de produção em chat, capturas de tela ou logs, mesmo em formato codificado.
• Para HTTP Basic Auth, o cabeçalho Base64 Authorization: Basic só é seguro sobre TLS (HTTPS). Sobre HTTP em texto puro, ele é trivialmente interceptável.
• Para confidencialidade real, use AES-GCM, age, sops ou um KMS — depois codifique o texto cifrado em Base64 para transporte, se necessário.

Para políticas rígidas de exfiltração de dados, salve esta página offline (Cmd/Ctrl + S). O codificador funciona totalmente isolado após um carregamento, já que não há dependência de servidor.

O codificador suporta arquivos de até 100 MB por meio do limite rígido no manipulador de arquivos — grande o suficiente para a maioria das imagens, PDFs, arquivos ZIP e até vídeos curtos. Metas de desempenho:

• < 1 MB: a codificação é concluída em <50 ms, sem travamento da interface.
• 1 – 10 MB: 100-500 ms dependendo da CPU. O navegador permanece responsivo porque codificamos em blocos de 32 KB.
• 10 – 100 MB: 2-15 segundos. A área de texto de saída pode travar levemente ao colar/rolar strings Base64 tão grandes. Considere baixar a saída como um arquivo .txt pelo DevTools, se necessário.
• > 100 MB: bloqueado — a sobrecarga de memória do navegador (bytes de entrada + string binária + string Base64 ≈ 3-4× o tamanho do arquivo) corre o risco de travar a aba. Use:

# macOS / Linux
base64 -i huge.bin -o huge.b64

# Windows PowerShell
$bytes = [IO.File]::ReadAllBytes('huge.bin')
[IO.File]::WriteAllText('huge.b64', [Convert]::ToBase64String($bytes))

Para fluxos de trabalho de streaming/multi-GB, consulte codificar arquivos grandes para Base64 para uma abordagem em blocos com Node.js/Python que evita carregar tudo na memória.

Este codificador usa UTF-8, a mesma codificação usada pela web moderna, JSON, Linux, macOS e quase todas as linguagens de programação por padrão. Nos bastidores, o texto é passado por new TextEncoder().encode(input), que sempre produz bytes UTF-8, e só então é codificado em Base64.

Por que isso importa: a antiga função JavaScript btoa() só lida com Latin-1 e lança InvalidCharacterError em caracteres como é, 中 ou 😀. Nosso wrapper cuida da conversão UTF-8 para você, de modo que emoji, chinês, japonês, coreano, árabe, cirílico e qualquer ponto de código Unicode sejam codificados corretamente.

Se você precisar de uma codificação diferente:
• UTF-16 LE (nativo do Windows): raro — geralmente um sinal de interoperabilidade legada. Mesmo assim, use new TextEncoder({ fatal: true }).encode(s) e converta a montante.
• ISO-8859-1 / Latin-1: mapeie manualmente os pontos de código 0-255 para bytes antes de codificar.
• GB18030, Shift_JIS, EUC-KR: use uma biblioteca como iconv-lite no Node.js para transcodificar primeiro.

Uma armadilha sutil: se seus dados de origem já estiverem em uma codificação não UTF-8 (por exemplo, ao ler um dump MySQL legado), decodifique-os primeiro com o codec correto, depois recodifique para UTF-8 antes de aplicar o Base64 — caso contrário, o Base64 decodificado preservará o mojibake.