Base64 code examples

const original = "Hello, World!"; // emoji & accents work too

// Encode (UTF-8 safe)
const bytes = new TextEncoder().encode(original);
const encoded = btoa(String.fromCharCode(...bytes));
console.log(`Encoded: ${encoded}`);

// Decode
const binary = atob(encoded);
const decoded = new TextDecoder().decode(
  Uint8Array.from(binary, (c) => c.charCodeAt(0))
);
console.log(`Decoded: ${decoded}`);

// Newer browsers / runtimes:
// const encoded = bytes.toBase64();
// const bytes = Uint8Array.fromBase64(encoded);

function base64Encode(input: string): string {
  const bytes = new TextEncoder().encode(input);
  let binary = "";
  bytes.forEach((b) => (binary += String.fromCharCode(b)));
  return btoa(binary);
}

function base64Decode(input: string): string {
  const binary = atob(input);
  const bytes = Uint8Array.from(binary, (c) => c.charCodeAt(0));
  return new TextDecoder().decode(bytes);
}

const original = "Hello, World!";
const encoded = base64Encode(original);
console.log(`Encoded: ${encoded}`);
console.log(`Decoded: ${base64Decode(encoded)}`);

const original = "Hello, World!";

// Encode
const encoded = Buffer.from(original, "utf8").toString("base64");
console.log(`Encoded: ${encoded}`);

// Decode
const decoded = Buffer.from(encoded, "base64").toString("utf8");
console.log(`Decoded: ${decoded}`);

// URL-safe variant
const urlSafe = Buffer.from(original).toString("base64url");

import base64

original = "Hello, World!"

# Encode
encoded = base64.b64encode(original.encode("utf-8")).decode("ascii")
print(f"Encoded: {encoded}")

# Decode
decoded = base64.b64decode(encoded).decode("utf-8")
print(f"Decoded: {decoded}")

# URL-safe variant
url_safe = base64.urlsafe_b64encode(original.encode()).decode()

import java.nio.charset.StandardCharsets;
import java.util.Base64;

public class Base64Example {
    public static void main(String[] args) {
        String original = "Hello, World!";

        // Encode
        String encoded = Base64.getEncoder()
            .encodeToString(original.getBytes(StandardCharsets.UTF_8));
        System.out.println("Encoded: " + encoded);

        // Decode
        String decoded = new String(
            Base64.getDecoder().decode(encoded), StandardCharsets.UTF_8);
        System.out.println("Decoded: " + decoded);

        // URL-safe: Base64.getUrlEncoder(), MIME: Base64.getMimeEncoder()
    }
}

using System;
using System.Text;

class Program
{
    static void Main()
    {
        string original = "Hello, World!";

        // Encode
        string encoded = Convert.ToBase64String(Encoding.UTF8.GetBytes(original));
        Console.WriteLine($"Encoded: {encoded}");

        // Decode
        string decoded = Encoding.UTF8.GetString(Convert.FromBase64String(encoded));
        Console.WriteLine($"Decoded: {decoded}");
    }
}

package main

import (
    "encoding/base64"
    "fmt"
)

func main() {
    original := "Hello, World!"

    // Encode
    encoded := base64.StdEncoding.EncodeToString([]byte(original))
    fmt.Println("Encoded:", encoded)

    // Decode
    decodedBytes, err := base64.StdEncoding.DecodeString(encoded)
    if err != nil {
        fmt.Println("Error decoding:", err)
        return
    }
    fmt.Println("Decoded:", string(decodedBytes))

    // URL-safe: base64.URLEncoding, unpadded: base64.RawStdEncoding
}

use base64::{engine::general_purpose::STANDARD, Engine as _};

fn main() {
    let original = "Hello, World!";

    // Encode
    let encoded = STANDARD.encode(original);
    println!("Encoded: {encoded}");

    // Decode
    let bytes = STANDARD.decode(&encoded).expect("invalid base64");
    let decoded = String::from_utf8(bytes).expect("invalid UTF-8");
    println!("Decoded: {decoded}");
}

<?php
$original = "Hello, World!";

// Encode
$encoded = base64_encode($original);
echo "Encoded: $encoded\n";

// Decode (strict mode rejects invalid characters)
$decoded = base64_decode($encoded, true);
echo "Decoded: $decoded\n";

#include <iostream>
#include <string>
#include <vector>

static const std::string base64_chars =
    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
    "abcdefghijklmnopqrstuvwxyz"
    "0123456789+/";

std::string base64_encode(const std::string &in) {
    std::string out;
    int val = 0, valb = -6;
    for (unsigned char c : in) {
        val = (val << 8) + c;
        valb += 8;
        while (valb >= 0) {
            out.push_back(base64_chars[(val >> valb) & 0x3F]);
            valb -= 6;
        }
    }
    if (valb > -6) out.push_back(base64_chars[((val << 8) >> (valb + 8)) & 0x3F]);
    while (out.size() % 4) out.push_back('=');
    return out;
}

std::string base64_decode(const std::string &in) {
    std::vector<int> T(256, -1);
    for (int i = 0; i < 64; i++) T[base64_chars[i]] = i;

    std::string out;
    int val = 0, valb = -8;
    for (unsigned char c : in) {
        if (T[c] == -1) break;
        val = (val << 6) + T[c];
        valb += 6;
        if (valb >= 0) {
            out.push_back(char((val >> valb) & 0xFF));
            valb -= 8;
        }
    }
    return out;
}

int main() {
    std::string original = "Hello, World!";
    std::string encoded = base64_encode(original);
    std::cout << "Encoded: " << encoded << std::endl;
    std::cout << "Decoded: " << base64_decode(encoded) << std::endl;
    return 0;
}

# Encode (printf avoids the trailing newline echo would add;
# single quotes stop the shell treating "!" as history expansion)
printf '%s' 'Hello, World!' | base64

# Decode (use -D on older macOS)
echo 'SGVsbG8sIFdvcmxkIQ==' | base64 --decode

# Encode a file without line wrapping (GNU coreutils)
base64 -w 0 image.png > image.b64

$original = "Hello, World!"

# Encode
$encoded = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($original))
Write-Output "Encoded: $encoded"

# Decode
$decoded = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String($encoded))
Write-Output "Decoded: $decoded"

# Encode a file
[Convert]::ToBase64String([IO.File]::ReadAllBytes("image.png"))