Gratis online tool om tekst naar Base64 te coderen of Base64-strings terug te decoderen naar tekst. Ondersteunt standaard en URL-veilige Base64-codering met directe conversie.
Base64 is een binaire-naar-tekst codering schema dat binaire gegevens in een ASCII tekenreeksformaat vertegenwoordigt. Het is ontworpen om gegevens die zijn opgeslagen in binaire formaten over te brengen via kanalen die alleen betrouwbaar tekstinhoud ondersteunen. Base64-codering converteert binaire gegevens in een set van 64 tekens (vandaar de naam) die veilig kunnen worden verzonden via tekstgebaseerde protocollen zonder gegevenscorruptie.
De Base64-tekenreeks bestaat uit:
Deze tool stelt je in staat om eenvoudig tekst naar Base64-formaat te coderen of Base64-strings terug te decoderen naar hun oorspronkelijke tekst. Het is bijzonder nuttig voor ontwikkelaars, IT-professionals en iedereen die met gegevens werkt die veilig moeten worden verzonden via tekstgebaseerde kanalen. Met onze realtime conversiefunctie kun je de resultaten onmiddellijk zien terwijl je typt, waardoor je codering en decodering workflow efficiënter wordt.
Base64-codering werkt door elke groep van drie bytes (24 bits) binaire gegevens om te zetten in vier Base64-tekens. Het proces volgt deze stappen:
Wanneer de invoerlengte niet deelbaar is door 3, wordt er padding met "="-tekens toegevoegd om de 4:3-verhouding van uitvoer tot invoerlengtes te behouden.
Voor een reeks bytes , worden de bijbehorende Base64-tekens berekend als:
Waar het -de teken in het Base64 alfabet vertegenwoordigt.
Base64-decodering keert het coderingproces om:
Wanneer het aantal te coderen bytes niet deelbaar is door 3, wordt padding toegepast:
Laten we de tekst "Hello" naar Base64 coderen:
Let op de "=" padding aan het einde omdat de invoerlengte (5 bytes) niet deelbaar is door 3.
De algemene formule voor het berekenen van de lengte van een Base64-gecodeerde string is:
Waar de plafondfunctie vertegenwoordigt (omhoog afronden naar het dichtstbijzijnde gehele getal).
Onze Base64-tool biedt een eenvoudige en efficiënte manier om tekst naar Base64 te coderen of Base64 terug naar tekst te decoderen. Hier is hoe je het kunt gebruiken:
Onze tool bevat nu een realtime conversieoptie die de uitvoer bijwerkt terwijl je typt:
De Live Conversiefunctie is bijzonder nuttig wanneer:
Voor zeer grote invoer gebruikt de tool debouncing om de prestaties te behouden, waardoor conversie alleen plaatsvindt nadat je even hebt gepauzeerd met typen, in plaats van bij elke toetsaanslag.
Base64-codering wordt op grote schaal gebruikt in verschillende toepassingen:
E-mailbijlagen: MIME (Multipurpose Internet Mail Extensions) gebruikt Base64 om binaire bijlagen in e-mail te coderen.
Gegevens-URL's: Kleine afbeeldingen, lettertypen of andere bronnen rechtstreeks in HTML, CSS of JavaScript insluiten met behulp van het data: URL-schema.
API-communicatie: Veilig binaire gegevens verzenden in JSON-payloads of andere tekstgebaseerde API-formaten.
Opslaan van binaire gegevens in tekstformaten: Wanneer binaire gegevens moeten worden opgeslagen in XML, JSON of andere tekstgebaseerde formaten.
Authentificatiesystemen: Basisauthenticatie in HTTP gebruikt Base64-codering (hoewel het niet voor beveiliging is, alleen voor codering).
Cryptografie: Als onderdeel van verschillende cryptografische protocollen en systemen, vaak voor het coderen van sleutels of certificaten.
Cookie-waarden: Complexe datastructuren coderen om in cookies te worden opgeslagen.
Hoewel Base64 veel wordt gebruikt, zijn er alternatieven die in bepaalde situaties geschikter kunnen zijn:
URL-veilige Base64: Een variant die "-" en "_" gebruikt in plaats van "+" en "/" om problemen met URL-codering te voorkomen. Nuttig voor gegevens die in URL's moeten worden opgenomen.
Base32: Gebruikt een 32-tekenreeks, wat resulteert in een langere uitvoer maar met betere leesbaarheid voor mensen en ongevoeligheid voor hoofdletters.
Hex Codering: Eenvoudige conversie naar hexadecimale waarden, die minder efficiënt is (verdubbelt de grootte) maar zeer eenvoudig en breed ondersteund.
Binaire Overdracht: Voor grote bestanden of wanneer efficiëntie cruciaal is, zijn directe binaire overdrachtprotocollen zoals HTTP met de juiste Content-Type headers te verkiezen.
Compressie + Base64: Voor grote tekstgegevens kan compressie vóór codering de groottevergroting verminderen.
JSON/XML Serialisatie: Voor gestructureerde gegevens kan het gebruik van native JSON- of XML-serialisatie geschikter zijn dan Base64-codering.
Base64-codering heeft zijn oorsprong in de vroege computer- en telecommunicatiesystemen waar binaire gegevens moesten worden verzonden over kanalen die voor tekst waren ontworpen.
De formele specificatie van Base64 werd voor het eerst gepubliceerd in 1987 als onderdeel van RFC 989, dat Privacy Enhanced Mail (PEM) definieerde. Dit werd later bijgewerkt in RFC 1421 (1993) en RFC 2045 (1996, als onderdeel van MIME).
De term "Base64" komt van het feit dat de codering 64 verschillende ASCII-tekens gebruikt om binaire gegevens te vertegenwoordigen. Deze keuze van 64 tekens was opzettelijk, aangezien 64 een macht van 2 is (2^6), wat de conversie tussen binaire en Base64 efficiënt maakt.
In de loop der tijd zijn er verschillende varianten van Base64 ontstaan:
Ondanks dat het meer dan drie decennia oud is, blijft Base64 een fundamenteel hulpmiddel in de moderne computertechnologie, vooral met de opkomst van webapplicaties en API's die sterk afhankelijk zijn van tekstgebaseerde gegevensformaten zoals JSON.
Hier zijn voorbeelden van Base64-codering en decodering in verschillende programmeertalen:
1// JavaScript Base64 Codering/Decodering
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("Ongeldige Base64-string");
11 }
12}
13
14// Voorbeeld gebruik
15const originalText = "Hello, World!";
16const encoded = encodeToBase64(originalText);
17console.log("Gecodeerd:", encoded); // SGVsbG8sIFdvcmxkIQ==
18
19try {
20 const decoded = decodeFromBase64(encoded);
21 console.log("Gedecodeerd:", decoded); // Hello, World!
22} catch (error) {
23 console.error(error.message);
24}
251# Python Base64 Codering/Decodering
2import base64
3
4def encode_to_base64(text):
5 # Converteer string naar bytes en codeer
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 # Converteer base64-string naar bytes en decodeer
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"Ongeldige Base64-string: {e}")
18
19# Voorbeeld gebruik
20original_text = "Hello, World!"
21encoded = encode_to_base64(original_text)
22print(f"Gecodeerd: {encoded}") # SGVsbG8sIFdvcmxkIQ==
23
24try:
25 decoded = decode_from_base64(encoded)
26 print(f"Gedecodeerd: {decoded}") # Hello, World!
27except ValueError as e:
28 print(e)
291// Java Base64 Codering/Decodering
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("Ongeldige Base64-string: " + e.getMessage());
19 }
20 }
21
22 public static void main(String[] args) {
23 String originalText = "Hello, World!";
24 String encoded = encodeToBase64(originalText);
25 System.out.println("Gecodeerd: " + encoded); // SGVsbG8sIFdvcmxkIQ==
26
27 try {
28 String decoded = decodeFromBase64(encoded);
29 System.out.println("Gedecodeerd: " + decoded); // Hello, World!
30 } catch (IllegalArgumentException e) {
31 System.err.println(e.getMessage());
32 }
33 }
34}
351<?php
2// PHP Base64 Codering/Decodering
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("Ongeldige Base64-string");
11 }
12 return $decoded;
13}
14
15// Voorbeeld gebruik
16$originalText = "Hello, World!";
17$encoded = encodeToBase64($originalText);
18echo "Gecodeerd: " . $encoded . "\n"; // SGVsbG8sIFdvcmxkIQ==
19
20try {
21 $decoded = decodeFromBase64($encoded);
22 echo "Gedecodeerd: " . $decoded . "\n"; // Hello, World!
23} catch (Exception $e) {
24 echo "Fout: " . $e->getMessage() . "\n";
25}
26?>
271// C# Base64 Codering/Decodering
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("Ongeldige Base64-string");
23 }
24 }
25
26 static void Main()
27 {
28 string originalText = "Hello, World!";
29 string encoded = EncodeToBase64(originalText);
30 Console.WriteLine($"Gecodeerd: {encoded}"); // SGVsbG8sIFdvcmxkIQ==
31
32 try
33 {
34 string decoded = DecodeFromBase64(encoded);
35 Console.WriteLine($"Gedecodeerd: {decoded}"); // Hello, World!
36 }
37 catch (FormatException e)
38 {
39 Console.WriteLine($"Fout: {e.Message}");
40 }
41 }
42}
431# Ruby Base64 Codering/Decodering
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 "Ongeldige Base64-string: #{e.message}"
13 end
14end
15
16# Voorbeeld gebruik
17original_text = "Hello, World!"
18encoded = encode_to_base64(original_text)
19puts "Gecodeerd: #{encoded}" # SGVsbG8sIFdvcmxkIQ==
20
21begin
22 decoded = decode_from_base64(encoded)
23 puts "Gedecodeerd: #{decoded}" # Hello, World!
24rescue StandardError => e
25 puts "Fout: #{e.message}"
26end
271// Go Base64 Codering/Decodering
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("ongeldige Base64-string: %v", err)
17 }
18 return string(bytes), nil
19}
20
21func main() {
22 originalText := "Hello, World!"
23 encoded := encodeToBase64(originalText)
24 fmt.Println("Gecodeerd:", encoded) // SGVsbG8sIFdvcmxkIQ==
25
26 decoded, err := decodeFromBase64(encoded)
27 if err != nil {
28 fmt.Println("Fout:", err)
29 } else {
30 fmt.Println("Gedecodeerd:", decoded) // Hello, World!
31 }
32}
331// Swift Base64 Codering/Decodering
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(_ base64_string: String) -> String? {
12 if let data = Data(base64Encoded: base64_string) {
13 return String(data: data, encoding: .utf8)
14 }
15 return nil
16}
17
18// Voorbeeld gebruik
19let originalText = "Hello, World!"
20if let encoded = encodeToBase64(originalText) {
21 print("Gecodeerd: \(encoded)") // SGVsbG8sIFdvcmxkIQ==
22
23 if let decoded = decodeFromBase64(encoded) {
24 print("Gedecodeerd: \(decoded)") // Hello, World!
25 } else {
26 print("Fout: Kon Base64-string niet decoderen")
27 }
28} else {
29 print("Fout: Kon tekst niet coderen")
30}
311' Excel VBA Base64 Codering/Decodering
2' Opmerking: Dit vereist een referentie naar 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(base64_string 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 = base64_string
30
31 DecodeFromBase64 = StrConv(xmlNode.nodeTypedValue, vbUnicode)
32
33 Set xmlNode = Nothing
34 Set xmlObj = Nothing
35 Exit Function
36
37ErrorHandler:
38 DecodeFromBase64 = "Fout: Ongeldige Base64-string"
39End Function
40
41' Gebruik in een werkblad:
42' =EncodeToBase64("Hello, World!")
43' =DecodeFromBase64("SGVsbG8sIFdvcmxkIQ==")
441# R Base64 Codering/Decodering
2# Vereist het 'base64enc' pakket
3# install.packages("base64enc")
4library(base64enc)
5
6encode_to_base64 <- function(text) {
7 # Converteer tekst naar rauwe bytes, dan coderen
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 # Converteer base64-string naar rauw, dan decoderen
16 base64_raw <- charToRaw(base64_string)
17 decoded_raw <- base64decode(base64_raw)
18 return(rawToChar(decoded_raw))
19 }, error = function(e) {
20 stop(paste("Ongeldige Base64-string:", e$message))
21 })
22}
23
24# Voorbeeld gebruik
25original_text <- "Hello, World!"
26encoded <- encode_to_base64(original_text)
27cat("Gecodeerd:", encoded, "\n") # SGVsbG8sIFdvcmxkIQ==
28
29tryCatch({
30 decoded <- decode_from_base64(encoded)
31 cat("Gedecodeerd:", decoded, "\n") # Hello, World!
32}, error = function(e) {
33 cat("Fout:", e$message, "\n")
34})
351% MATLAB Base64 Codering/Decodering
2function demo_base64()
3 originalText = 'Hello, World!';
4
5 % Coderen
6 encoded = encode_to_base64(originalText);
7 fprintf('Gecodeerd: %s\n', encoded); % SGVsbG8sIFdvcmxkIQ==
8
9 % Decoderen
10 try
11 decoded = decode_from_base64(encoded);
12 fprintf('Gedecodeerd: %s\n', decoded); % Hello, World!
13 catch e
14 fprintf('Fout: %s\n', e.message);
15 end
16end
17
18function encoded = encode_to_base64(text)
19 % Converteer tekst naar uint8-array en codeer
20 bytes = uint8(text);
21 encoded = base64encode(bytes);
22end
23
24function decoded = decode_from_base64(base64_string)
25 try
26 % Decodeer base64-string naar uint8-array
27 bytes = base64decode(base64_string);
28 decoded = char(bytes);
29 catch
30 error('Ongeldige Base64-string');
31 end
32end
331// C Base64 Codering/Decodering met 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; // Ongeldige Base64-invoer
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 = "Hello, World!";
58
59 char* encoded = encode_to_base64(original_text);
60 printf("Gecodeerd: %s\n", encoded); // SGVsbG8sIFdvcmxkIQ==
61
62 char* decoded = decode_from_base64(encoded);
63 if (decoded) {
64 printf("Gedecodeerd: %s\n", decoded); // Hello, World!
65 free(decoded);
66 } else {
67 printf("Fout: Ongeldige Base64-string\n");
68 }
69
70 free(encoded);
71
72 return 0;
73}
741// Rust Base64 Codering/Decodering
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!("Ongeldige UTF-8-sequentie: {}", e))
15 }
16 },
17 Err(e) => Err(format!("Ongeldige Base64-string: {}", e))
18 }
19}
20
21fn main() {
22 let original_text = "Hello, World!";
23 let encoded = encode_to_base64(original_text);
24 println!("Gecodeerd: {}", encoded); // SGVsbG8sIFdvcmxkIQ==
25
26 match decode_from_base64(&encoded) {
27 Ok(decoded) => println!("Gedecodeerd: {}", decoded), // Hello, World!
28 Err(e) => println!("Fout: {}", e)
29 }
30}
31Hier is een voorbeeld van hoe je de live conversiefunctie in JavaScript kunt implementeren:
1// JavaScript implementatie met live conversie
2const textInput = document.getElementById('text-input');
3const base64Output = document.getElementById('base64-output');
4const liveConversionCheckbox = document.getElementById('live-conversion');
5let debounceTimeout = null;
6
7// Functie om te coderen met debouncing voor prestaties
8function liveEncode() {
9 // Wis eventuele bestaande timeout
10 if (debounceTimeout) {
11 clearTimeout(debounceTimeout);
12 }
13
14 // Stel een nieuwe timeout in om overmatige verwerking tijdens snel typen te voorkomen
15 debounceTimeout = setTimeout(() => {
16 try {
17 const text = textInput.value;
18 if (text.trim()) {
19 base64Output.value = btoa(text);
20 } else {
21 base64Output.value = '';
22 }
23 } catch (e) {
24 console.error('Codering fout:', e);
25 // Behandel fout op een geschikte manier in de UI
26 }
27 }, 300); // 300ms debounce vertraging
28}
29
30// Evenementenlisteners
31liveConversionCheckbox.addEventListener('change', function() {
32 if (this.checked) {
33 // Schakel live conversie in
34 textInput.addEventListener('input', liveEncode);
35 // Initiële codering
36 liveEncode();
37 } else {
38 // Schakel live conversie uit
39 textInput.removeEventListener('input', liveEncode);
40 }
41});
42Bij het werken met Base64-codering en decodering, wees je bewust van deze belangrijke overwegingen:
Unicode en Niet-ASCII-tekens: Zorg ervoor dat je de juiste tekencodering (meestal UTF-8) gebruikt voordat je Base64-codering toepast bij tekst met niet-ASCII-tekens.
Padding: Standaard Base64 gebruikt padding met "="-tekens om ervoor te zorgen dat de uitvoerlengte een veelvoud van 4 is. Sommige implementaties staan het weglaten van padding toe, wat compatibiliteitsproblemen kan veroorzaken.
Regelafbrekingen: Traditionele Base64-implementaties voegen regelafbrekingen in (meestal elke 76 tekens) toe voor leesbaarheid, maar moderne toepassingen laten deze vaak weg.
URL-veilige Base64: Standaard Base64 gebruikt "+" en "/" tekens die speciale betekenissen hebben in URL's. Voor URL-contexten, gebruik URL-veilige Base64 die deze vervangt door "-" en "_".
Witruimtes: Bij decoderen zijn sommige implementaties soepel en negeren ze witruimtes, terwijl andere exacte invoer vereisen.
Grootte Verhoging: Base64-codering verhoogt de grootte van gegevens met ongeveer 33% (4 uitvoerbytes voor elke 3 invoerbytes).
Prestaties: Base64-codering/decodering kan rekenintensief zijn voor zeer grote gegevens. Onze tool gebruikt debouncing om de responsiviteit te behouden, zelfs met grotere invoeren.
Live Conversie Overwegingen: Wanneer je de live conversiefunctie gebruikt met zeer grote invoeren, kun je een lichte vertraging opmerken terwijl de tool de gegevens verwerkt. Dit is normaal en helpt de prestaties van de browser te behouden.
De Live Conversiefunctie werkt de uitvoer automatisch bij terwijl je typt, zonder dat je op de codering of decoderen knop hoeft te klikken. Dit biedt onmiddellijke feedback en maakt de tool interactiever en efficiënter in gebruik.
Onze implementatie gebruikt debouncing om goede prestaties te waarborgen, zelfs met grotere invoeren. De conversie vindt alleen plaats nadat je even hebt gepauzeerd met typen, in plaats van bij elke toetsaanslag, wat overmatige verwerking tijdens snel typen voorkomt.
Live Conversie is ideaal voor interactief werk waarbij je onmiddellijke feedback wilt. Voor zeer grote datasets of wanneer je je invoer wilt bekijken voordat je converteert, geef je misschien de voorkeur aan de handmatige conversieoptie.
Ja, de Live Conversiefunctie werkt in beide richtingen - van tekst naar Base64 en van Base64 naar tekst.
Als je ongeldig Base64-tekens invoert terwijl je in decodemodus met Live Conversie bent, zal de tool een foutmelding in realtime weergeven, waardoor je het probleem onmiddellijk kunt identificeren en corrigeren.
Probeer vandaag onze Base64 Encoder/Decoder tool om snel tussen tekst en Base64-formaten te converteren met de gemak van realtime conversie. Of je nu een ontwikkelaar bent die met API's werkt, e-mailbijlagen afhandelt of binaire gegevens in tekstformaten insluit, onze tool maakt het proces eenvoudig en efficiënt.
Ontdek meer tools die handig kunnen zijn voor uw workflow