Base62 Encoder

Base62 encoding and decoding in your browser

A Base62 encoder and decoder converts text into a compact string made only from digits and letters, and it can also turn valid Base62 data back into readable text.

This tool supports two Base62 alphabets:

• Standard (0-9 A-Z a-z)
• Lower-first (0-9 a-z A-Z)

You can use it to:

• encode text into Base62
• decode Base62 back into UTF-8 text
• switch between two common Base62 alphabets
• process single values or batch-convert multiple lines
• trim messy input automatically in batch mode
• wrap long encoded output at 76 characters
• copy the result instantly

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

---

What Base62 actually is

Base62 is a binary-to-text encoding that represents data using a 62-character alphabet.

Instead of symbols or punctuation, it uses only:

• digits 0-9
• uppercase letters A-Z
• lowercase letters a-z

That makes Base62 useful when you want encoded output that is:

• compact
• text-safe
• made only from letters and digits
• friendlier for URLs, filenames, and identifiers than punctuation-heavy formats

Because Base62 has more symbols than Base32 or Base36, it can often represent data more compactly while still staying alphanumeric.

---

Why Base62 is useful

Base62 is often used when you want short strings without special characters.

This makes it useful for:

• compact IDs
• short codes
• URL-friendly identifiers
• database or app references
• encoded values used in developer tooling
• situations where punctuation should be avoided

Compared with Base64, Base62 avoids symbols like +, /, and =. Compared with Base58, it keeps the full letter-and-digit range instead of removing potentially ambiguous characters.

---

The two supported Base62 variants

One of the most important things about Base62 is that there is no single universal alphabet order.

That means two different systems can both say “Base62” while using different character mappings.

This tool supports two common variants.

Standard (0-9 A-Z a-z)

This variant uses:

0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz

This is a very common Base62 ordering and is often what developers mean by “standard Base62.”

Lower-first (0-9 a-z A-Z)

This variant uses:

0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

This is also used in real systems and libraries.

Important: variant mismatch matters

These variants are not interchangeable.

A string encoded with one alphabet must be decoded with the same alphabet.

If you choose the wrong variant:

• decoding can fail
• or the output can decode incorrectly

This is one of the most common sources of confusion when working with Base62.

---

What this tool does

This Base62 tool combines encoding, decoding, variant switching, and batch processing in one interface.

You can:

• switch between Encode and Decode mode
• choose the Base62 alphabet variant
• process one value or many values separated by newlines
• trim copied lines automatically
• wrap encoded output at 76 characters for readability
• copy the result instantly

Because the output updates live, it is easy to compare variants, validate strings, and test conversions quickly.

---

Important Base62 detail: no padding

Unlike Base64, Base62 does not use padding.

That means there are no trailing = characters to preserve or remove.

In this tool, the Strip padding option is present only for consistency with similar encoder tools, but it remains disabled because Base62 does not use padding.

This is expected behavior.

---

How to use the tool

1. Choose encode or decode

Use the mode toggle inside the input area:

• Encode turns text into Base62
• Decode turns Base62 back into readable text

2. Choose the Base62 variant

Select the alphabet your workflow expects:

• Standard (0-9 A-Z a-z)
• Lower-first (0-9 a-z A-Z)

If you are decoding existing Base62 data, choosing the correct variant is critical.

3. Paste or type your input

Depending on the selected mode:

• in Encode mode, enter normal text
• in Decode mode, paste Base62 data

4. Decide whether to batch by newline

If Batch by newline is enabled, each non-empty line is processed separately.

This is useful when working with:

• lists of IDs
• test strings
• many encoded values
• copied datasets from docs or logs

5. Keep Trim lines enabled when needed

If your source contains extra spaces around each line, Trim lines helps clean it before conversion.

6. Use Wrap @ 76 for long encoded output

In encode mode, you can enable Wrap @ 76 to insert line breaks every 76 characters for readability.

7. Copy the result

Use the Copy button to move the output wherever you need it.

---

Understanding the controls

Variant selector

This decides which Base62 alphabet is used for encoding or decoding.

It is the most important control when working with existing Base62 strings from outside systems.

Batch by newline

When enabled, the tool processes one line at a time.

Example input:

alpha
beta
gamma

Produces one output line per input line.

This is ideal for bulk conversion and repeated testing.

Trim lines

This removes leading and trailing spaces from each line before processing.

It is useful when input comes from:

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

Wrap @ 76

This inserts a line break every 76 characters in encoded output.

It can help when:

• reviewing long strings
• copying into fixed-width text contexts
• improving readability in documentation or notes

Strip padding

Base62 has no padding, so this option remains disabled.

That is normal and expected.

---

Practical examples

Encode text into compact alphanumeric output

If you want a compact representation made only from digits and letters, use Encode mode.

This is useful for:

• testing encoding output
• generating compact reference strings
• building text-safe examples for documentation

Decode Base62 back into text

If you already have a Base62 value and want to inspect the original text, switch to Decode mode.

This is useful for:

• debugging
• validation
• verifying conversion logic
• comparing how different variants behave

Compare Standard vs Lower-first alphabets

If a decoded result fails or looks wrong, try switching the variant.

That can immediately reveal whether the original data came from a different Base62 implementation.

Batch-convert many strings at once

Paste one item per line and process the full list in a single pass.

This saves time when working with:

• fixtures
• sample payloads
• lists of identifiers
• repeated conversion tasks

---

Common mistakes and how to fix them

“Invalid Base62 character”

This means the input contains characters outside the selected Base62 alphabet.

Fix:

• verify the string uses only letters and digits from the chosen variant
• remove accidental invalid characters
• keep Trim lines enabled for copied input

The decoded result looks wrong

This often means the data was encoded using the other Base62 alphabet.

Fix:

• switch between Standard and Lower-first
• decode again using the matching variant

I expected padding, but there is none

That is normal. Base62 does not use padding.

Fix:

• no action needed
• ignore the disabled Strip padding option

Long encoded values are hard to read

Use Wrap @ 76 in encode mode to make output easier to inspect visually.

---

Leading zeros and the first alphabet character

Like other integer-based text encodings, Base62 needs to preserve leading zero bytes.

In this tool, each leading zero byte is represented by the first character of the selected alphabet.

That means:

• in the Standard variant, leading zero bytes become leading 0
• in the Lower-first variant, they also become leading 0

This is not decorative text. It preserves part of the original byte structure.

---

How Base62 works at a high level

At a high level, Base62 conversion works like this:

Encoding

1. your input text is converted into bytes
2. the byte sequence is treated as a large integer
3. that integer is repeatedly divided by 62
4. each remainder maps to one character in the selected Base62 alphabet
5. leading zero bytes are preserved using the alphabet’s zero digit

Decoding

1. each Base62 character is converted back into its numeric value
2. those values are recombined into one large integer
3. the integer is turned back into bytes
4. the bytes are decoded back into text

This is why the alphabet order matters so much: different alphabets map the same character positions differently.

---

Why this tool is useful

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

This tool is useful when you want:

• a quick browser-based Base62 converter
• side-by-side input and output
• support for multiple Base62 alphabets
• batch processing without extra setup
• privacy without uploading data anywhere

It is especially practical for developers, QA workflows, debugging, documentation work, and any project dealing with compact alphanumeric identifiers.

---

Perfect for

• developers testing Base62 strings and IDs
• support and QA teams validating encoded values
• makers building compact alphanumeric identifiers
• anyone comparing Base62 alphabet variants across systems
• anyone who needs a private, browser-based Base62 encoder and decoder

Encode, decode, batch-convert, switch variants, and copy the result — all without opening a terminal or sending your data anywhere.