Integer Base Converter

Convert integers between bases 2–64

Supports binary, octal, decimal, hexadecimal, base64, and custom bases (2–64)

Last updated: January 24, 2026

CreatorFrank Zhao

Convert

Input number

Input base

Custom output base

Results

Binary (2)

101010

Octal (8)

Decimal (10)

Hexadecimal (16)

Base64 (64)

Custom (10)

Introduction / overview

The Integer Base Converter translates a whole number from one base (radix) to another — anywhere from $2$ to $64$ . It’s perfect when you bounce between binary, octal, decimal, hexadecimal, and “custom” bases used in programming, data formats, and compact identifiers.

What problem does it solve?

Quickly verify conversions (e.g., hex logs to decimal) without mental arithmetic.
Move between human-friendly formats (decimal) and machine-friendly formats (binary/hex).
Interpret “weird base” digit sets for compact IDs (up to $64$ ).

This converter runs locally in your browser. If you’re pasting sensitive identifiers, you’re not sending them to a server from this tool.

If you’re working with tokens and IDs, you may also like our Token Generator or UUID Generator to create values, then use this converter to inspect or transform their numeric parts.

How to use / quick start

Step-by-step

Enter your number

Type the integer exactly as written in its current base (no prefixes like $0x$ ).

Set the input base

Choose the base the number is currently in. For binary use $2$ , for hex use $16$ .

Pick an output base

You’ll see common outputs (binary/oct/dec/hex/base64) plus a custom output base.

Copy the result

Use the copy button next to an output row to paste it into code, a document, or a config file.

Mini diagram (what happens under the hood)

Input

Digits in base $b$ (input base)

Convert

Output

Same value expressed in base $b$ (output base)

In practice, the tool converts to an internal integer value and then re-encodes it using the target base’s digit set.

How to interpret outputs

If you change the output base, the digits change but the underlying value stays the same.
For bases above $10$ , digits extend into letters (and above $36$ , uppercase letters, then $+$ and $/$ ).

Digit set used by this tool (bases up to $64$ )

This converter uses a fixed digit set in this exact order:

0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+/

Example: in base $16$ , the digits are 0–9 and a–f.

Real-world examples / use cases

Example 1: Decimal to binary (sanity check)

Background: you see $42$ in a UI, but a config file needs binary.

Inputs: value $42$ , input base $10$ , output base $2$ .

42_{10}

=

101010_{2}

How to apply it: if you ever doubt the binary output, convert it back to decimal and confirm it returns $42$ .

Example 2: Hex to decimal (log parsing)

Background: a system log prints a code like 7b and you need the decimal value.

Inputs: value $\text{7b}$ , input base $16$ , output base $10$ .

\text{7b}_{16}

=

7\cdot 16^1 + 11\cdot 16^0

=

112 + 11

=

123_{10}

How to apply it: you can now compare the code numerically (thresholds, ordering, etc.). If you’re hashing values for logs, pairing with our Hash Text tool can be handy.

Example 3: Base64 digits (compact integer IDs)

Background: you store an integer ID in a compact base $64$ representation.

Inputs: value $\text{2P}$ , input base $64$ , output base $10$ .

\text{2P}_{64}

=

2\cdot 64^1 + 51\cdot 64^0

=

128 + 51

=

179_{10}

How to apply it: you can sort IDs numerically, or switch to base $16$ for debugging. If you’re generating IDs, you may prefer ULID Generator for lexicographic ordering.

Example 4: Binary bitmasks (feature flags)

Background: a flag value is stored as binary, but you want its decimal form for an API call.

Inputs: value $\text{10010110}$ , input base $2$ , output base $10$ .

\text{10010110}_{2}

=

150_{10}

How to apply it: convert back to binary after editing the decimal value so you don’t accidentally flip the wrong bits.

Common scenarios / when to use

These are the moments where a base converter saves real time — especially when you’re switching contexts between code, databases, and debugging tools.

Reading hex in logs

Convert $16$ → $10$ to compare values and thresholds.

Editing bitmasks

Convert $2$ ↔ $10$ to verify which bits are set.

Compact integer IDs

Convert to base $64$ for shorter strings; convert back for sorting/debugging.

Inspecting identifiers

Convert pieces of IDs to check ranges, shards, or embedded timestamps.

Security review notes

Convert numeric constants to confirm key sizes and boundaries.

Copy/paste across tools

Convert once, then copy the output row you need (hex for dev tools, decimal for docs).

When it may not be a fit

If you need base64 encoding of bytes or text (RFC 4648), this tool’s “base64” is digit-based integer notation.
If you’re working with decimals/fractions, you’ll need a different converter (this one is integers only).

Tips & best practices

Normalize your input

Remove spaces and separators before converting. For hex-like values, avoid prefixes like $0x$ and keep letters consistent with the tool’s digit set.

Do a quick round-trip check

Convert $A \to B$ and then back $B \to A$ . If you get the original digits, you can trust the conversion.

Watch for invalid digits

In base $2$ , only $0$ and $1$ are allowed. Any other digit should be treated as an error.

Remember: base64 here is not text encoding

This tool’s base $64$ uses digits $0\ldots 9$ , letters, plus $+$ and $/$ . It does not perform byte-to-text base64 encoding.

Common mistakes to avoid

Mixing digit sets: A is not the same as a in this digit order.
Copying prefixes/suffixes: avoid 0x, b, underscores, and commas.
Leading minus sign: negative integers are not supported by this converter.

Calculation method / formula explanation

Base conversion relies on positional notation. If a number has digits $d_k d_{k-1}\ldots d_1 d_0$ in base $b$ , its value is the weighted sum of each digit.

N = \sum_{i=0}^{k} d_i\, b^i

(positional value in base b)

Variables explained

$b$ is the base (radix), where $2 \le b \le 64$ .
$d_i$ is the value of the digit at position $i$ (starting from the right at $i=0$ ).
$N$ is the resulting integer value.

Worked conversion (shown as a multi-step layout)

Convert $\text{1a}_{16}$ to decimal:

\text{1a}_{16}

=

1\cdot 16^1 + 10\cdot 16^0

=

16 + 10

=

26_{10}

The only “trick” is remembering that the digit $a$ means $10$ in base $16$ .

Related concepts / background

Positional notation

In any base $b$ , the place values are powers of $b^0, b^1, b^2, \ldots$ . That’s why a single digit can “mean” different things depending on where it sits.

Digit sets and case sensitivity

For bases above $10$ , the tool uses letters as additional digits. In this converter, lowercase and uppercase are distinct digits once you go above $36$ .

Practical tip: if you’re expecting “classic hex” with uppercase A–F, either keep your input lowercase, or switch to a consistent format before converting.

Why base conversion matters

Debugging: quickly interpret machine-oriented values (hex addresses, bitmasks).
Storage: represent the same integer using fewer characters with larger bases.
Interop: some systems require a specific notation (e.g., config expects base $2$ or $16$ ).

Frequently asked questions (FAQs)

What bases does this converter support?

Any integer base from $2$ to $64$ . That includes binary, octal, decimal, hexadecimal, and a base $64$ digit set.

Does it support negative numbers?

No — inputs must be non-negative integers. A leading minus sign is treated as an invalid digit.

Why does my value show “invalid digit”?

It means at least one character isn’t allowed in the input base. For example, base $2$ allows only $0$ and $1$ .

Remove spaces, underscores, or prefixes (like 0x).
Double-check letter case when working above base $36$ .

Is “Base64 (64)” the same as Base64 encoding?

Not exactly. “Base $64$ ” here means “write an integer using $64$ possible digits.” Base64 encoding (RFC 4648) converts bytes to text and uses padding rules; this converter doesn’t do that.

How can I double-check a conversion manually?

Use positional notation: multiply each digit by a power of the base and sum them. For a quick check, a small number is easiest.

\text{1011}_{2}

=

1\cdot 2^3 + 0\cdot 2^2 + 1\cdot 2^1 + 1\cdot 2^0

=

11_{10}

Can this handle very large integers?

Yes, up to your browser’s practical limits. Under the hood, this kind of converter typically uses arbitrary-size integers (like JavaScript $\text{BigInt}$ ) so you’re not constrained by $2^{53}-1$ the way normal numbers are.

Limitations / disclaimers

Integers only: no decimals, fractions, or scientific notation.
No negative sign support.
The digit set is fixed (shown above). If another system uses a different digit order, results may differ.
This tool is for convenience and education; always validate critical conversions in your target system.

External references / sources

Related Calculators

Chronometer

Use a simple chronometer (stopwatch) to track elapsed time down to milliseconds. Runs locally in your browser.

Try Now

Email normalizer

Normalize email addresses to a standard format for easier comparison. Useful for deduplication and data cleaning. Runs locally in your browser.

Try Now

ETA calculator

Estimate the time needed to consume a total amount at a constant rate, and get an expected end time. Runs locally in your browser.

Try Now

JWT parser

Parse and decode your JSON Web Token (JWT) and display its content. All computation runs locally in your browser.

Try Now

MIME types

Know which file extensions are associated to a MIME type, and which MIME type is associated to a file extension. Includes a full MIME types table.

Try Now

Lorem ipsum generator

Generate random Lorem Ipsum placeholder text with customizable paragraphs, sentences, and word counts. Runs locally in your browser.

Try Now