Amol Pawar

If you’ve ever poked around APIs, email attachments, or image data in HTML, chances are you’ve stumbled upon a long, strange-looking string of characters — often ending with = signs. That’s Base64 Encoding.

In this post, we’ll break down what Base64 Encoding is, how it works, when to use it, and why it’s so widely used in the tech world .

What Is Base64 Encoding?

At its core, Base64 Encoding is a way to represent binary data (like files, images, or raw bytes) as plain text using only readable characters — specifically letters, numbers, +, /, and sometimes = for padding.

This is useful because some systems and protocols (like older email systems or JSON data in APIs) can’t handle binary data directly. Encoding it as text ensures it can safely travel through text-only channels.

Think of it as a translation layer between binary and text.

How Base64 Encoding Works

Here’s the basic idea:

Base64 encoding splits your binary data into chunks of 6 bits each. 

Why 6 bits? Because 2 to the power of 6 is 64, which means 64 unique symbols fit perfectly to represent each possible 6-bit sequence.

1. Binary Data → Groups of 6 Bits
    Computers store everything in binary (0s and 1s). Base64 takes this binary data and processes it in chunks of 6 bits instead of the usual 8 bits (a byte).
2. Mapping to a Character Set
    Each 6-bit chunk maps to one of 64 characters (hence the name “Base64”). The character set includes:

A–Z (26 characters)   
a–z (26 characters)   
0–9 (10 characters)   
+ and / (2 characters)

1. Padding with =
    If the total bits don’t divide evenly into 6-bit groups, = signs are added at the end to keep the encoded string length a multiple of 4.

Example: Encoding a Simple Word

Let’s see what happens when we encode the word Hi.

Step 1: Convert to ASCII Binary

H → 72 in decimal → 01001000  
i → 105 in decimal → 01101001

Step 2: Combine into One Binary Stream

01001000 01101001

Step 3: Split into 6-Bit Groups

010010 000110 1001 (pad with two 0s) → 010010 000110 100100

Step 4: Map to Base64 Table

010010 → S  
000110 → G  
100100 → k

Step 5: Add Padding
 Since we had missing bits at the end, we pad with =.

Final Base64 Encoding:

SGk=

Base64 Encoding in Code

Here’s a Kotlin example for encoding and decoding:

import java.util.Base64

fun main() {
    // Original text
    val originalText = "Hello, Base64!"

    // Convert the string to bytes (UTF-8 encoding)
    val bytes = originalText.toByteArray(Charsets.UTF_8)

    // Encode the bytes to Base64 string
    val encodedString = Base64.getEncoder().encodeToString(bytes)

    // Print the encoded Base64 string
    println("Encoded: $encodedString")
}

Here,

• We start with the string "Hello, Base64!" stored in originalText.
• toByteArray(Charsets.UTF_8) converts the string into a byte array using UTF-8 encoding, which is necessary because Base64 operates on byte data.
• Base64.getEncoder().encodeToString(bytes) encodes the byte array into a Base64-encoded string using Java’s built-in Base64 encoder accessible in Kotlin.
• Finally, we print the encoded Base64 string.

When you run this code, the output will be:

Encoded: SGVsbG8sIEJhc2U2NCE=

When to Use Base64 Encoding

Base64 Encoding is not for encryption or compression. It’s purely for safe data transport. Here are common use cases:

• Email Attachments (MIME Encoding)
   Older email systems can’t handle binary files directly. Base64 makes them safe to send.
• Embedding Images in HTML/CSS
   Instead of linking to an image file, you can embed it directly as Base64 inside HTML or CSS:

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

• Storing Binary Data in JSON/XML
   Many APIs use Base64 to represent file data as plain text.
• Authentication (Basic Auth)
   In HTTP Basic Authentication, credentials are often Base64 encoded (though this is not secure on its own).

Why Base64 Matters

Base64 Encoding solves a practical problem: moving binary data through systems that only handle text. It’s a universal translator that works across platforms, languages, and protocols.

That said, it comes with trade-offs:

• Larger size: Base64 increases data size by about 33%.
• Not secure: It’s easily reversible, so don’t use it for sensitive data without encryption.

In short, Base64 matters because it keeps data intact during transmission — even if the channel can’t handle raw bytes.

Key Takeaways

• Base64 Encoding turns binary data into text-safe characters.
• It’s about compatibility, not security.
• Use it when data needs to travel through systems that don’t support raw binary.
• Always combine it with encryption if security is a concern.

Conclusion

By understanding Base64 Encoding, you’ll be better equipped to debug API responses, embed resources in code, and handle binary data with confidence.

If you want to try it yourself, grab a Base64 encoder/decoder online and test with some text or an image. 

Seeing the transformation in action makes it click instantly.

When we talk to each other, our brains are constantly performing an amazing trick — encoding thoughts into words and decoding words back into thoughts. Computers and digital devices do something similar, but instead of words and emotions, they deal with bits, bytes, and signals.

In this blog, we’ll break down the Encoding–Decoding concept, explore how it works in both human communication and digital systems, and even look at a simple Kotlin example to make things crystal clear.

What Is Encoding–Decoding?

Encoding–Decoding is a process of converting information from one form into another so it can be transmitted or stored, and then converting it back to its original form.

Think of it like sending a message in a secret code:

• Encoding → Writing your message in the secret code.
• Transmission → Sending it to your friend.
• Decoding → Your friend translating it back into the original message.

In humans, encoding happens when you put your thoughts into words. Decoding happens when someone hears those words and interprets their meaning. In computers, it’s about transforming data into a machine-readable format and then back to human-readable form.

Everyday Examples of Encoding–Decoding

1. Human Conversation

• Encoding: You think “I’m hungry” and say, “Let’s get pizza.”
• Decoding: Your friend hears you and understands you want to eat pizza.

2. Digital Communication

• Encoding: Your phone takes your typed message “Hello” and turns it into binary (like 01001000 01100101 01101100 01101100 01101111).
• Transmission: The binary data travels over a network.
• Decoding: The receiver’s phone converts the binary back into the word “Hello” on their screen.

Why Encoding–Decoding Matters

Without encoding, we wouldn’t be able to store files, send emails, or stream videos. Without decoding, the information would remain an unreadable jumble of data. It’s the bridge that makes communication — whether human or digital — possible.

Encoding–Decoding also ensures:

• Compatibility: Data can be read across devices and platforms.
• Efficiency: Compressed encoding makes file sizes smaller.
• Security: Encryption is a special kind of encoding to protect information.

Encoding–Decoding in Digital Systems

In computers, encoding can be text encoding (like UTF-8), image encoding (like JPEG), or audio encoding (like MP3). Decoding is the reverse process.

For example:

• When you save a .txt file, your computer encodes the letters into numbers based on a standard like ASCII or Unicode.
• When you open that file, your computer decodes the numbers back into readable text.

Kotlin Example: Encoding and Decoding Text

Let’s look at a simple Kotlin program that encodes a string into Base64 and decodes it back. Base64 is a common encoding method used to safely transmit text data over systems that may not handle binary data well.

import java.util.Base64

fun main() {
    val originalText = "Encoding–Decoding in Kotlin"
    
    // Encoding the text to Base64
    val encodedText = Base64.getEncoder()
        .encodeToString(originalText.toByteArray(Charsets.UTF_8))
    println("Encoded Text: $encodedText")
    
    // Decoding the Base64 back to the original text
    val decodedText = String(
        Base64.getDecoder().decode(encodedText),
        Charsets.UTF_8
    )
    println("Decoded Text: $decodedText")
}

1. Import the Base64 library
    Kotlin uses Java’s built-in Base64 class for encoding and decoding.
2. Original Text
    We start with a string: "Encoding–Decoding in Kotlin".

Encoding

• originalText.toByteArray(Charsets.UTF_8) converts the text into bytes.
• Base64.getEncoder().encodeToString(...) transforms those bytes into a Base64-encoded string.

Decoding

• Base64.getDecoder().decode(encodedText) converts the Base64 string back into bytes.
• String(..., Charsets.UTF_8) turns those bytes back into readable text.

Output might look like:

Encoded Text: RW5jb2RpbmfigJlkZWNvZGluZyBpbiBLb3RsaW4=
Decoded Text: Encoding–Decoding in Kotlin

Beyond Base64: Other Types of Encoding–Decoding

• Text Encoding: ASCII, UTF-8, UTF-16
• Data Compression: GZIP, ZIP
• Encryption: AES, RSA (for security)
• Media Encoding: JPEG, MP4, MP3

Each has its own purpose — some focus on compatibility, some on storage efficiency, and others on privacy.

Conclusion

Whether it’s two friends talking over coffee or two computers sending gigabytes of data across the globe, Encoding–Decoding is the invisible hero of communication.

By understanding it, you not only get a peek into how humans share ideas but also into the magic that powers your favorite apps, websites, and devices.

If you’re learning programming, experimenting with encoding and decoding in Kotlin is a great way to bridge the gap between theory and practice.