Ferramenta online gratuita para codificar texto em Base64 ou decodificar strings Base64 de volta para texto. Suporta codificação Base64 padrão e segura para URL com conversão instantânea.
Base64 é um esquema de codificação de texto binário que representa dados binários em um formato de string ASCII. Ele foi projetado para transportar dados armazenados em formatos binários através de canais que suportam confiavelmente apenas conteúdo de texto. A codificação Base64 converte dados binários em um conjunto de 64 caracteres (daí o nome) que podem ser transmitidos com segurança por meio de protocolos baseados em texto, sem corrupção de dados.
O conjunto de caracteres Base64 consiste em:
Esta ferramenta permite que você codifique facilmente texto para o formato Base64 ou decodifique strings Base64 de volta para seu texto original. É particularmente útil para desenvolvedores, profissionais de TI e qualquer pessoa que trabalhe com dados que precisam ser transmitidos com segurança através de canais baseados em texto. Com nosso recurso de conversão em tempo real, você pode ver instantaneamente os resultados enquanto digita, tornando seu fluxo de trabalho de codificação e decodificação mais eficiente.
A codificação Base64 funciona convertendo cada grupo de três bytes (24 bits) de dados binários em quatro caracteres Base64. O processo segue estas etapas:
Quando o comprimento da entrada não é divisível por 3, um preenchimento com caracteres "=" é adicionado para manter a proporção de 4:3 dos comprimentos de saída para entrada.
Para uma sequência de bytes , os caracteres Base64 correspondentes são calculados como:
Onde representa o -ésimo caractere no alfabeto Base64.
A decodificação Base64 reverte o processo de codificação:
Quando o número de bytes a serem codificados não é divisível por 3, o preenchimento é aplicado:
Vamos codificar o texto "Olá" para Base64:
Note o preenchimento "=" no final porque o comprimento da entrada (3 bytes) não é divisível por 3.
A fórmula geral para calcular o comprimento de uma string codificada em Base64 é:
Onde representa a função teto (arredondando para o inteiro mais próximo).
Nossa ferramenta Base64 fornece uma maneira simples e eficiente de codificar texto em Base64 ou decodificar Base64 de volta para texto. Veja como usá-la:
Nossa ferramenta agora inclui uma opção de conversão em tempo real que atualiza a saída enquanto você digita:
O recurso de Conversão ao Vivo é particularmente útil quando:
Para entradas muito grandes, a ferramenta usa debouncing para manter o desempenho, garantindo que a conversão só ocorra após você pausar a digitação brevemente, em vez de em cada pressionamento de tecla.
A codificação Base64 é amplamente utilizada em várias aplicações:
Anexos de Email: MIME (Extensões de Correio da Internet Multipropósito) usa Base64 para codificar anexos binários em emails.
URLs de Dados: Incorporando pequenas imagens, fontes ou outros recursos diretamente em HTML, CSS ou JavaScript usando o esquema de URL data:.
Comunicações de API: Transmitindo dados binários com segurança em cargas úteis JSON ou outros formatos de API baseados em texto.
Armazenando Dados Binários em Formatos de Texto: Quando dados binários precisam ser armazenados em XML, JSON ou outros formatos baseados em texto.
Sistemas de Autenticação: A Autenticação Básica em HTTP usa codificação Base64 (embora não seja para segurança, apenas para codificação).
Criptografia: Como parte de vários protocolos e sistemas criptográficos, muitas vezes para codificar chaves ou certificados.
Valores de Cookies: Codificando estruturas de dados complexas para serem armazenadas em cookies.
Embora Base64 seja amplamente utilizado, existem alternativas que podem ser mais apropriadas em certas situações:
Base64 Seguro para URL: Uma variante que usa "-" e "_" em vez de "+" e "/" para evitar problemas de codificação de URL. Útil para dados que serão incluídos em URLs.
Base32: Usa um conjunto de 32 caracteres, resultando em uma saída mais longa, mas com melhor legibilidade humana e insensibilidade a maiúsculas/minúsculas.
Codificação Hexadecimal: Conversão simples para hexadecimal, que é menos eficiente (dobra o tamanho) mas muito simples e amplamente suportada.
Transferência Binária: Para arquivos grandes ou quando a eficiência é crucial, protocolos de transferência binária direta como HTTP com cabeçalhos Content-Type apropriados são preferíveis.
Compressão + Base64: Para grandes dados de texto, comprimir antes de codificar pode mitigar o aumento de tamanho.
Serialização JSON/XML: Para dados estruturados, usar a serialização nativa JSON ou XML pode ser mais apropriado do que a codificação Base64.
A codificação Base64 tem suas raízes na computação e sistemas de telecomunicações antigos, onde dados binários precisavam ser transmitidos por canais projetados para texto.
A especificação formal do Base64 foi publicada pela primeira vez em 1987 como parte do RFC 989, que definiu o Correio Privado Aprimorado (PEM). Isso foi posteriormente atualizado no RFC 1421 (1993) e no RFC 2045 (1996, como parte do MIME).
O termo "Base64" vem do fato de que a codificação usa 64 caracteres ASCII diferentes para representar dados binários. Essa escolha de 64 caracteres foi deliberada, uma vez que 64 é uma potência de 2 (2^6), o que torna a conversão entre binário e Base64 eficiente.
Com o tempo, várias variantes do Base64 surgiram:
Apesar de ter mais de três décadas, o Base64 continua sendo uma ferramenta fundamental na computação moderna, particularmente com o aumento de aplicativos web e APIs que dependem fortemente de formatos de dados baseados em texto como JSON.
Aqui estão exemplos de codificação e decodificação Base64 em várias linguagens de programação:
1// Codificação/Decodificação Base64 em JavaScript
2function encodeToBase64(text) {
3 return btoa(text);
4}
5
6function decodeFromBase64(base64String) {
7 try {
8 return atob(base64String);
9 } catch (e) {
10 throw new Error("String Base64 inválida");
11 }
12}
13
14// Exemplo de uso
15const originalText = "Olá, Mundo!";
16const encoded = encodeToBase64(originalText);
17console.log("Codificado:", encoded); // T2xhLCBNdW5kbyE=
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Decodificado:", decoded); // Olá, Mundo!
22} catch (error) {
23 console.error(error.message);
24}
251# Codificação/Decodificação Base64 em Python
2import base64
3
4def encode_to_base64(text):
5 # Converte string para bytes e depois codifica
6 text_bytes = text.encode('utf-8')
7 base64_bytes = base64.b64encode(text_bytes)
8 return base64_bytes.decode('utf-8')
9
10def decode_from_base64(base64_string):
11 try:
12 # Converte string base64 para bytes e depois decodifica
13 base64_bytes = base64_string.encode('utf-8')
14 text_bytes = base64.b64decode(base64_bytes)
15 return text_bytes.decode('utf-8')
16 except Exception as e:
17 raise ValueError(f"String Base64 inválida: {e}")
18
19# Exemplo de uso
20original_text = "Olá, Mundo!"
21encoded = encode_to_base64(original_text)
22print(f"Codificado: {encoded}") # T2xhLCBNdW5kbyE=
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Decodificado: {decoded}") # Olá, Mundo!
27except ValueError as e:
28 print(e)
291// Codificação/Decodificação Base64 em Java
2import java.util.Base64;
3import java.nio.charset.StandardCharsets;
4
5public class Base64Example {
6 public static String encodeToBase64(String text) {
7 byte[] textBytes = text.getBytes(StandardCharsets.UTF_8);
8 byte[] encodedBytes = Base64.getEncoder().encode(textBytes);
9 return new String(encodedBytes, StandardCharsets.UTF_8);
10 }
11
12 public static String decodeFromBase64(String base64String) {
13 try {
14 byte[] base64Bytes = base64String.getBytes(StandardCharsets.UTF_8);
15 byte[] decodedBytes = Base64.getDecoder().decode(base64Bytes);
16 return new String(decodedBytes, StandardCharsets.UTF_8);
17 } catch (IllegalArgumentException e) {
18 throw new IllegalArgumentException("String Base64 inválida: " + e.getMessage());
19 }
20 }
21
22 public static void main(String[] args) {
23 String originalText = "Olá, Mundo!";
24 String encoded = encodeToBase64(originalText);
25 System.out.println("Codificado: " + encoded); // T2xhLCBNdW5kbyE=
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Decodificado: " + decoded); // Olá, Mundo!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// Codificação/Decodificação Base64 em PHP
3function encodeToBase64($text) {
4 return base64_encode($text);
5}
6
7function decodeFromBase64($base64String) {
8 $decoded = base64_decode($base64String, true);
9 if ($decoded === false) {
10 throw new Exception("String Base64 inválida");
11 }
12 return $decoded;
13}
14
15// Exemplo de uso
16$originalText = "Olá, Mundo!";
17$encoded = encodeToBase64($originalText);
18echo "Codificado: " . $encoded . "\n"; // T2xhLCBNdW5kbyE=
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Decodificado: " . $decoded . "\n"; // Olá, Mundo!
23} catch (Exception $e) {
24 echo "Erro: " . $e->getMessage() . "\n";
25}
26?>
271// Codificação/Decodificação Base64 em C#
2using System;
3using System.Text;
4
5class Base64Example
6{
7 public static string EncodeToBase64(string text)
8 {
9 byte[] textBytes = Encoding.UTF8.GetBytes(text);
10 return Convert.ToBase64String(textBytes);
11 }
12
13 public static string DecodeFromBase64(string base64String)
14 {
15 try
16 {
17 byte[] base64Bytes = Convert.FromBase64String(base64String);
18 return Encoding.UTF8.GetString(base64Bytes);
19 }
20 catch (FormatException)
21 {
22 throw new FormatException("String Base64 inválida");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Olá, Mundo!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Codificado: {encoded}"); // T2xhLCBNdW5kbyE=
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Decodificado: {decoded}"); // Olá, Mundo!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Erro: {e.Message}");
40 }
41 }
42}
431# Codificação/Decodificação Base64 em Ruby
2require 'base64'
3
4def encode_to_base64(text)
5 Base64.strict_encode64(text)
6end
7
8def decode_from_base64(base64_string)
9 begin
10 Base64.strict_decode64(base64_string)
11 rescue ArgumentError => e
12 raise "String Base64 inválida: #{e.message}"
13 end
14end
15
16# Exemplo de uso
17original_text = "Olá, Mundo!"
18encoded = encode_to_base64(original_text)
19puts "Codificado: #{encoded}" # T2xhLCBNdW5kbyE=
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Decodificado: #{decoded}" # Olá, Mundo!
24rescue StandardError => e
25 puts "Erro: #{e.message}"
26end
271// Codificação/Decodificação Base64 em Go
2package main
3
4import (
5 "encoding/base64"
6 "fmt"
7)
8
9func encodeToBase64(text string) string {
10 return base64.StdEncoding.EncodeToString([]byte(text))
11}
12
13func decodeFromBase64(base64_string string) (string, error) {
14 bytes, err := base64.StdEncoding.DecodeString(base64_string)
15 if err != nil {
16 return "", fmt.Errorf("string Base64 inválida: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Olá, Mundo!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Codificado:", encoded) // T2xhLCBNdW5kbyE=
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Erro:", err)
29 } else {
30 fmt.Println("Decodificado:", decoded) // Olá, Mundo!
31 }
32}
331// Codificação/Decodificação Base64 em Swift
2import Foundation
3
4func encodeToBase64(_ text: String) -> String? {
5 if let data = text.data(using: .utf8) {
6 return data.base64EncodedString()
7 }
8 return nil
9}
10
11func decodeFromBase64(_ base64String: String) -> String? {
12 if let data = Data(base64Encoded: base64String) {
13 return String(data: data, encoding: .utf8)
14 }
15 return nil
16}
17
18// Exemplo de uso
19let originalText = "Olá, Mundo!"
20if let encoded = encodeToBase64(originalText) {
21 print("Codificado: \(encoded)") // T2xhLCBNdW5kbyE=
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Decodificado: \(decoded)") // Olá, Mundo!
25 } else {
26 print("Erro: Não foi possível decodificar a string Base64")
27 }
28} else {
29 print("Erro: Não foi possível codificar o texto")
30}
311' Codificação/Decodificação Base64 em VBA do Excel
2' Nota: Isso requer uma referência ao Microsoft XML, v6.0
3Function EncodeToBase64(text As String) As String
4 Dim xmlObj As Object
5 Set xmlObj = CreateObject("MSXML2.DOMDocument")
6
7 Dim xmlNode As Object
8 Set xmlNode = xmlObj.createElement("b64")
9
10 xmlNode.DataType = "bin.base64"
11 xmlNode.nodeTypedValue = StrConv(text, vbFromUnicode)
12
13 EncodeToBase64 = xmlNode.text
14
15 Set xmlNode = Nothing
16 Set xmlObj = Nothing
17End Function
18
19Function DecodeFromBase64(base64String As String) As String
20 On Error GoTo ErrorHandler
21
22 Dim xmlObj As Object
23 Set xmlObj = CreateObject("MSXML2.DOMDocument")
24
25 Dim xmlNode As Object
26 Set xmlNode = xmlObj.createElement("b64")
27
28 xmlNode.DataType = "bin.base64"
29 xmlNode.text = base64String
30
31 DecodeFromBase64 = StrConv(xmlNode.nodeTypedValue, vbUnicode)
32
33 Set xmlNode = Nothing
34 Set xmlObj = Nothing
35 Exit Function
36
37ErrorHandler:
38 DecodeFromBase64 = "Erro: String Base64 inválida"
39End Function
40
41' Uso em uma planilha:
42' =EncodeToBase64("Olá, Mundo!")
43' =DecodeFromBase64("T2xhLCBNdW5kbyE=")
441# Codificação/Decodificação Base64 em R
2# Requer o pacote 'base64enc'
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Converte texto para bytes brutos, depois codifica
8 text_raw <- charToRaw(text)
9 base64_encoded <- base64encode(text_raw)
10 return(rawToChar(base64_encoded))
11}
12
13decode_from_base64 <- function(base64_string) {
14 tryCatch({
15 # Converte string base64 para bytes brutos, depois decodifica
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("String Base64 inválida:", e$message))
21 })
22}
23
24# Exemplo de uso
25original_text <- "Olá, Mundo!"
26encoded <- encode_to_base64(original_text)
27cat("Codificado:", encoded, "\n") # T2xhLCBNdW5kbyE=
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Decodificado:", decoded, "\n") # Olá, Mundo!
32}, error = function(e) {
33 cat("Erro:", e$message, "\n")
34})
351% Codificação/Decodificação Base64 em MATLAB
2function demo_base64()
3 originalText = 'Olá, Mundo!';
4
5 % Codificar
6 encoded = encode_to_base64(originalText);
7 fprintf('Codificado: %s\n', encoded); % T2xhLCBNdW5kbyE=
8
9 % Decodificar
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Decodificado: %s\n', decoded); % Olá, Mundo!
13 catch e
14 fprintf('Erro: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Converte texto para array uint8 e codifica
20 bytes = uint8(text);
21 encoded = matlab.net.base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64String)
25 try
26 % Decodifica string base64 para array uint8
27 bytes = matlab.net.base64decode(base64String);
28 decoded = char(bytes);
29 catch
30 error('String Base64 inválida');
31 end
32end
331// Codificação/Decodificação Base64 em C usando OpenSSL
2#include <stdio.h>
3#include <string.h>
4#include <openssl/bio.h>
5#include <openssl/evp.h>
6#include <openssl/buffer.h>
7#include <stdint.h>
8
9char* encode_to_base64(const char* input) {
10 BIO *bio, *b64;
11 BUF_MEM *bufferPtr;
12
13 b64 = BIO_new(BIO_f_base64());
14 bio = BIO_new(BIO_s_mem());
15 bio = BIO_push(b64, bio);
16
17 BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
18 BIO_write(bio, input, strlen(input));
19 BIO_flush(bio);
20 BIO_get_mem_ptr(bio, &bufferPtr);
21
22 char* result = (char*)malloc(bufferPtr->length + 1);
23 memcpy(result, bufferPtr->data, bufferPtr->length);
24 result[bufferPtr->length] = '\0';
25
26 BIO_free_all(bio);
27
28 return result;
29}
30
31char* decode_from_base64(const char* input) {
32 BIO *bio, *b64;
33 size_t length = strlen(input);
34 char* buffer = (char*)malloc(length);
35
36 b64 = BIO_new(BIO_f_base64());
37 bio = BIO_new_mem_buf(input, -1);
38 bio = BIO_push(b64, bio);
39
40 BIO_set_flags(bio, BIO_FLAGS_BASE64_NO_NL);
41 int decoded_length = BIO_read(bio, buffer, length);
42
43 if (decoded_length <= 0) {
44 free(buffer);
45 BIO_free_all(bio);
46 return NULL; // Entrada Base64 inválida
47 }
48
49 buffer[decoded_length] = '\0';
50
51 BIO_free_all(bio);
52
53 return buffer;
54}
55
56int main() {
57 const char* original_text = "Olá, Mundo!";
58
59 char* encoded = encode_to_base64(original_text);
60 printf("Codificado: %s\n", encoded); // T2xhLCBNdW5kbyE=
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Decodificado: %s\n", decoded); // Olá, Mundo!
65 free(decoded);
66 } else {
67 printf("Erro: String Base64 inválida\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Codificação/Decodificação Base64 em Rust
2use base64::{encode, decode};
3use std::str;
4
5fn encode_to_base64(text: &str) -> String {
6 encode(text)
7}
8
9fn decode_from_base64(base64_string: &str) -> Result<String, String> {
10 match decode(base64_string) {
11 Ok(bytes) => {
12 match str::from_utf8(&bytes) {
13 Ok(text) => Ok(text.to_string()),
14 Err(e) => Err(format!("Sequência UTF-8 inválida: {}", e))
15 }
16 },
17 Err(e) => Err(format!("String Base64 inválida: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Olá, Mundo!";
23 let encoded = encode_to_base64(original_text);
24 println!("Codificado: {}", encoded); // T2xhLCBNdW5kbyE=
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Decodificado: {}", decoded), // Olá, Mundo!
28 Err(e) => println!("Erro: {}", e)
29 }
30}
311// Implementação JavaScript com Conversão ao Vivo
2
3const textInput = document.getElementById('text-input');
4const base64Output = document.getElementById('base64-output');
5const liveConversionCheckbox = document.getElementById('live-conversion');
6let debounceTimeout = null;
7
8// Função para codificar com debouncing para desempenho
9function liveEncode() {
10 // Limpa qualquer timeout existente
11 if (debounceTimeout) {
12 clearTimeout(debounceTimeout);
13 }
14
15 // Define um novo timeout para evitar processamento excessivo durante a digitação rápida
16 debounceTimeout = setTimeout(() => {
17 try {
18 const text = textInput.value;
19 if (text.trim()) {
20 base64Output.value = btoa(text);
21 } else {
22 base64Output.value = '';
23 }
24 } catch (e) {
25 console.error('Erro de codificação:', e);
26 // Lida com erro de maneira apropriada na UI
27 }
28 }, 300); // 300ms de atraso de debouncing
29}
30
31// Listeners de eventos
32liveConversionCheckbox.addEventListener('change', function() {
33 if (this.checked) {
34 // Ativa a conversão ao vivo
35 textInput.addEventListener('input', liveEncode);
36 // Codifica inicialmente
37 liveEncode();
38 } else {
39 // Desativa a conversão ao vivo
40 textInput.removeEventListener('input', liveEncode);
41 }
42});
43Ao trabalhar com codificação e decodificação Base64, esteja ciente dessas considerações importantes:
Unicode e Caracteres Não ASCII: Ao codificar texto com caracteres não ASCII, assegure-se de usar a codificação de caracteres apropriada (geralmente UTF-8) antes da codificação Base64.
Preenchimento: O Base64 padrão usa preenchimento com caracteres "=" para garantir que o comprimento da saída seja um múltiplo de 4. Algumas implementações permitem omitir o preenchimento, o que pode causar problemas de compatibilidade.
Quebras de Linha: Implementações tradicionais de Base64 inserem quebras de linha (tipicamente a cada 76 caracteres) para legibilidade, mas aplicativos modernos frequentemente omitem isso.
Base64 Seguro para URL: O Base64 padrão usa os caracteres "+" e "/" que têm significados especiais em URLs. Para contextos de URL, use Base64 seguro para URL que substitui esses por "-" e "_".
Espaços em Branco: Ao decodificar, algumas implementações são tolerantes e ignoram espaços em branco, enquanto outras exigem entrada exata.
Aumento de Tamanho: A codificação Base64 aumenta o tamanho dos dados em aproximadamente 33% (4 bytes de saída para cada 3 bytes de entrada).
Desempenho: A codificação/decodificação Base64 pode ser intensiva em computação para dados muito grandes. Nossa ferramenta usa debouncing para manter a responsividade mesmo com entradas maiores.
Considerações sobre Conversão ao Vivo: Ao usar o recurso de conversão ao vivo com entradas muito grandes, você pode notar um leve atraso enquanto a ferramenta processa os dados. Isso é normal e ajuda a manter o desempenho do navegador.
O recurso de Conversão ao Vivo atualiza automaticamente a saída à medida que você digita, sem precisar clicar no botão de codificação ou decodificação. Isso fornece feedback instantâneo e torna a ferramenta mais interativa e eficiente de usar.
Nossa implementação usa debouncing para garantir um bom desempenho mesmo com entradas grandes. A conversão só ocorre após você pausar a digitação brevemente, em vez de em cada pressionamento de tecla, o que evita processamento excessivo durante a digitação rápida.
A Conversão ao Vivo é ideal para trabalho interativo onde você deseja feedback imediato. Para conjuntos de dados muito grandes ou quando deseja revisar sua entrada antes da conversão, você pode preferir a opção de conversão manual.
Sim, o recurso de Conversão ao Vivo funciona em ambas as direções - de texto para Base64 e de Base64 para texto.
Se você inserir caracteres Base64 inválidos enquanto estiver no modo de decodificação com a Conversão ao Vivo ativada, a ferramenta exibirá uma mensagem de erro em tempo real, ajudando você a identificar e corrigir o problema imediatamente.
Experimente nossa ferramenta Codificador/Decodificador Base64 hoje para converter rapidamente entre texto e formatos Base64 com a conveniência da conversão em tempo real. Seja você um desenvolvedor trabalhando com APIs, lidando com anexos de email ou incorporando dados binários em formatos de texto, nossa ferramenta torna o processo simples e eficiente.
Descubra mais ferramentas que podem ser úteis para o seu fluxo de trabalho