Base45 Encoder

Encode and decode Base45 directly in your browser

A Base45 encoder and decoder converts text into a QR-friendly encoded format defined in RFC 9285, and it can also turn valid Base45 strings back into readable UTF‑8 text.

Base45 is designed for environments where:

• compact text encoding matters
• QR code compatibility is important
• restricted text alphabets are preferred
• binary data needs to travel through text-based systems

This tool lets you:

• encode UTF‑8 text into Base45
• decode Base45 back into readable text
• process single values or batch-convert many lines at once
• preserve the official RFC 9285 alphabet
• wrap encoded output at 76 characters
• copy results instantly

Everything runs locally in your browser, so your workflow stays private, fast, and easy to repeat.

---

What Base45 actually is

Base45 is a binary-to-text encoding.

Like Base32, Base58, Base64, and Base91, it converts raw byte data into readable text characters.

However, Base45 was specifically designed around the QR code alphanumeric character set.

Its alphabet contains:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ $%*+-./:

That means Base45 intentionally includes:

• digits
• uppercase letters
• spaces
• several punctuation symbols

The goal is not maximum compression.

Instead, the goal is efficient use of QR code alphanumeric mode, where this restricted alphabet can often store data more efficiently than larger alphabets.

---

Why Base45 became important

Base45 became widely recognized through the:

• EU Digital COVID Certificate (EUDCC)
• related QR-based payload systems

In those workflows, binary certificate data was:

1. compressed
2. encoded as Base45
3. embedded into QR codes

Because the alphabet matches QR alphanumeric mode well, the resulting QR codes could remain smaller and easier to scan.

Today, Base45 is still useful for:

• QR code experiments
• payload transport
• developer tooling
• debugging encoded data
• standards testing
• interoperability checks

---

Base45 vs Base64

Base45 and Base64 solve similar problems, but they optimize for different things.

Base64

Base64:

• uses 64 characters
• is more space-efficient in raw text
• is extremely common in APIs and web systems
• includes characters like + and /

Base45

Base45:

• uses only 45 characters
• is less compact in plain text
• works efficiently with QR alphanumeric mode
• avoids lowercase letters entirely
• uses a QR-friendly alphabet

So while Base64 usually produces shorter text strings, Base45 can still produce better QR code efficiency overall in the right environments.

---

What this Base45 tool can do

This tool combines:

• Base45 encoding
• Base45 decoding
• batch processing
• live output updates
• QR-friendly formatting

in one browser-based interface.

You can:

• switch between Encode and Decode mode
• process one value or many newline-separated values
• trim lines automatically when needed
• wrap encoded output at 76 characters
• instantly copy the result

Because output updates live, it is easy to:

• test payloads
• validate examples
• compare encoded values
• debug conversion workflows

without writing scripts or opening a terminal.

---

Important Base45 detail: spaces are valid characters

Unlike many other encodings, Base45 treats the space character as part of the official alphabet.

That means spaces are not automatically invalid.

This matters because:

• some Base45 strings legitimately contain spaces
• trimming or removing spaces incorrectly can corrupt encoded data
• wrapped Base45 output should preserve internal spaces exactly

This tool preserves valid Base45 spacing behavior while still allowing optional line trimming in batch workflows.

---

How to use the tool

1. Choose encode or decode

Use the mode toggle inside the input area:

• Encode turns text into Base45
• Decode converts Base45 back into readable text

2. Enter your input

Depending on the selected mode:

• in Encode mode, enter plain UTF‑8 text
• in Decode mode, paste Base45 data

3. Decide whether to batch by newline

If Batch by newline is enabled:

• each non-empty line is processed independently
• output alignment is preserved
• failed lines show inline errors without breaking valid lines

This is useful for:

• test vectors
• payload lists
• debugging multiple values
• comparing QR payloads

4. Optional formatting

In encode mode, you can enable:

• Wrap @ 76

This inserts line breaks every 76 characters for readability.

5. Copy the result

Use the Copy button in the output panel to copy the converted value instantly.

---

Understanding the controls

Batch by newline

When enabled, the tool processes each line separately.

Example:

alpha
beta
gamma

Produces one Base45 result per line.

This is especially useful for:

• repeated testing
• fixture generation
• payload comparisons
• bulk conversion workflows

---

Trim lines

Trim lines removes leading and trailing whitespace from each line before processing.

This helps when input comes from:

• copied spreadsheets
• logs
• pasted datasets
• manually edited lists

However, because spaces are valid Base45 characters, this option defaults more conservatively than in some other encoder tools.

---

Wrap @ 76

This inserts a newline every 76 characters during encoding.

It is useful when:

• reviewing long encoded payloads
• formatting examples for documentation
• improving readability
• pasting into systems that prefer wrapped text blocks

For most QR workflows, unwrapped output is also completely valid.

---

Practical examples

Encode text into QR-friendly Base45

If you need a QR-compatible encoded payload, use Encode mode.

This is useful for:

• QR code generation experiments
• standards testing
• interoperability checks
• payload transport

---

Decode Base45 back into readable text

If you already have Base45 data and want to inspect the original content, switch to Decode mode.

This is useful for:

• debugging
• payload inspection
• validating encoded examples
• comparing conversion behavior

---

Batch-process many values at once

Paste one value per line and keep Batch by newline enabled.

This is ideal for:

• test fixtures
• sample payloads
• encoded datasets
• repeated validation workflows

---

Generate wrapped Base45 output

Enable Wrap @ 76 when long encoded strings become difficult to inspect visually.

This can make documentation and debugging much easier.

---

Common mistakes and how to fix them

“Invalid Base45 character”

This means the input contains a character outside the RFC 9285 alphabet.

Fix:

• remove unsupported characters
• verify the data was actually encoded as Base45
• ensure smart quotes or formatting artifacts were not introduced during copying

---

The decoded result looks wrong

This can happen when:

• the original payload was binary rather than UTF‑8 text
• the input was truncated
• spaces or symbols were accidentally modified

Fix:

• verify the original source format
• ensure the Base45 string is complete
• preserve spaces exactly when copying encoded values

---

The encoded output is longer than expected

This is normal.

Base45 is not optimized for the shortest possible text output.

Its main advantage is compatibility with QR code alphanumeric mode, not raw text density.

---

Wrapped output no longer decodes elsewhere

Some systems do not expect newline-wrapped Base45.

Fix:

• disable Wrap @ 76
• or remove line breaks before importing into the target system

This tool automatically ignores line breaks during decoding.

---

How Base45 works at a high level

Internally, Base45 works by converting bytes into groups represented by Base45 characters.

Encoding

1. your text becomes UTF‑8 bytes
2. byte pairs are combined into numeric values
3. those values are converted into Base45 digits
4. each digit maps to one character from the RFC 9285 alphabet

Most two-byte groups become three Base45 characters.

A final single byte becomes two Base45 characters.

Decoding

1. Base45 characters are converted back into numeric values
2. the values are recombined into bytes
3. the bytes are decoded back into UTF‑8 text

This process is fully reversible as long as the encoded data remains unchanged.

---

Base45 is encoding, not encryption

Base45 is often confused with encryption because the output looks unreadable.

However, Base45 provides:

• no secrecy
• no password protection
• no cryptographic security

Anyone can decode valid Base45 data back into its original bytes.

If you need security or confidentiality, use proper encryption instead.

---

Why this tool is useful

Many Base45 tasks are small enough that writing a custom script would be unnecessary overhead.

This tool is useful when you want:

• a quick browser-based Base45 converter
• side-by-side input and output
• batch processing without setup
• QR-friendly payload testing
• private local processing without uploads

It is especially practical for developers, QA workflows, debugging, interoperability testing, standards experimentation, and QR-based workflows.

---

Perfect for

• developers working with QR payloads
• testing RFC 9285 Base45 examples
• decoding Base45 values from documentation or APIs
• validating encoded text line-by-line
• batch-converting many values at once
• anyone who needs a fast, private Base45 encoder and decoder

Encode, decode, batch-process, wrap, copy, and validate Base45 data directly in your browser — without uploading anything or opening a terminal.