Base64 Encode Online

How Base64 encoding works

The encoder reads the input 3 bytes at a time. Those 24 bits are cut into four groups of 6 bits, and each group, a number from 0 to 63, picks one character from the alphabet ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/. Here is Hi! done by hand:

• Bytes: H is 72, i is 105 and ! is 33. In binary: 01001000 01101001 00100001.
• Regrouped into 6 bits: 010010 000110 100100 100001, which are the numbers 18, 6, 36 and 33.
• Positions 18, 6, 36 and 33 in the alphabet are S, G, k and h, so Hi! encodes to SGkh.

Padding, size and what Base64 doesn't do

When the input isn't a multiple of 3 bytes, the end is padded. One leftover byte gives two characters and ==, two leftover bytes give three characters and =. So M is TQ==, Ma is TWE= and Man is TWFu. For n bytes the output is 4 * ceil(n / 3) characters, about a third more than the input.

Base64 hides nothing. There's no key, and the Base64 Decoder reverses it in one step. If a value has to stay secret, encrypt it first, for example with AES encryption, and use Base64 only to carry the ciphertext as text.

Base64 or Base64URL?

Standard Base64 uses + and /. In a URL, + is often read as a space, / splits the path, and = separates keys from values in a query string. RFC 4648 section 5 defines a URL and filename safe alphabet that uses - in place of + and _ in place of /, normally without padding.

• Standard Base64: MIME email, data: URLs, HTTP Basic auth, Kubernetes Secrets, PEM certificates, and most APIs whose docs just say "Base64".
• Base64URL: all three parts of a JWT (paste one into the JWT Decoder to see them), PKCE code challenges, WebAuthn data, URL parameters and file names.
• Check what the receiving side expects. Java's and Go's standard decoders reject - and _, and Python's b64decode quietly drops them, giving wrong bytes with no error, unless you pass validate=True.

One line, or 76 characters per line?

The encoder here gives one unbroken line. That's what JSON, HTTP headers, environment variables and Kubernetes manifests expect. A few formats want line breaks:

• MIME email (RFC 2045) limits encoded lines to 76 characters. GNU base64 on Linux also wraps at 76 by default, which is how a value pasted from the terminal ends up breaking a YAML file. Run base64 -w 0 there to get one line.
• PEM files, such as certificates and private keys, wrap at 64 characters between their BEGIN and END lines (RFC 7468).
• To wrap the output yourself, pipe it through fold -w 76, or use a MIME encoder in code, such as Base64.getMimeEncoder() in Java.

Base64 encode a string in code

Each snippet encodes the UTF-8 bytes of the string. In JavaScript, btoa() only accepts characters with codes 0 to 255, so turn the text into UTF-8 bytes first.

const bytes = new TextEncoder().encode("Café 👋");
btoa(String.fromCharCode(...bytes));
// 'Q2Fmw6kg8J+Riw=='
// Above roughly 100 KB the spread can overflow the call stack,
// so build the string in chunks for big inputs.

// Current browsers also have toBase64() on byte arrays:
bytes.toBase64();
// 'Q2Fmw6kg8J+Riw=='
bytes.toBase64({ alphabet: "base64url", omitPadding: true });
// 'Q2Fmw6kg8J-Riw'

Buffer.from("Café 👋", "utf8").toString("base64");
// 'Q2Fmw6kg8J+Riw=='
Buffer.from("Café 👋", "utf8").toString("base64url");
// 'Q2Fmw6kg8J-Riw'

import base64

data = "Café 👋".encode("utf-8")
base64.b64encode(data).decode("ascii")
# 'Q2Fmw6kg8J+Riw=='
base64.urlsafe_b64encode(data).decode("ascii")
# 'Q2Fmw6kg8J-Riw==' (URL-safe, but keeps the = padding)

base64.StdEncoding.EncodeToString([]byte("Café 👋"))
// URL-safe, no padding:
base64.RawURLEncoding.EncodeToString([]byte("Café 👋"))

byte[] bytes = "Café 👋".getBytes(StandardCharsets.UTF_8);
Base64.getEncoder().encodeToString(bytes);
// URL-safe, no padding:
Base64.getUrlEncoder().withoutPadding().encodeToString(bytes);

Convert.ToBase64String(Encoding.UTF8.GetBytes("Café 👋"));

// PHP strings are bytes; a UTF-8 source file gives UTF-8.
base64_encode("Café 👋"); // 'Q2Fmw6kg8J+Riw=='

printf '%s' 'Hello, world!' | base64
# SGVsbG8sIHdvcmxkIQ==
# Don't use echo: it adds a newline, giving SGVsbG8sIHdvcmxkIQo=

[Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes("Café 👋"))

Base64 encode a file or an image

The encoder on this page takes text. For a file, encode its raw bytes in code, because reading a PNG or a PDF as text first corrupts every byte that isn't valid UTF-8. A data: URL is that Base64 with a data:<type>;base64, prefix. Inline only small images this way, a few kilobytes at most: the Base64 is a third bigger than the file, and the browser can't cache it separately from the page.

base64 -w 0 logo.png > logo.b64   # Linux (GNU coreutils)
base64 -i logo.png -o logo.b64    # macOS

# As a data: URL (Linux):
printf 'data:image/png;base64,%s' "$(base64 -w 0 logo.png)"

import { readFileSync } from "node:fs";

const b64 = readFileSync("logo.png").toString("base64");
const dataUrl = "data:image/png;base64," + b64;

import base64, pathlib

b64 = base64.b64encode(pathlib.Path("logo.png").read_bytes()).decode("ascii")
data_url = "data:image/png;base64," + b64

const file = document.querySelector("input[type=file]").files[0];
const reader = new FileReader();
reader.onload = () => console.log(reader.result); // "data:image/png;base64,..."
reader.readAsDataURL(file);

[Convert]::ToBase64String([IO.File]::ReadAllBytes("logo.png"))