Home
Text to Binary Converter Binary to Text Converter Text to Hex Converter Hex to Text Converter Text to Decimal Converter Decimal to Text Converter Text to UTF-8 Hex Converter Text to EBCDIC Hex Converter Decimal to BCD Converter UTF-8 Hex to Text Converter EBCDIC to Text Converter BCD to Decimal Converter
About

Binary to Decimal Converter

Trying to figure out what a binary string actually equals? The Binary to Decimal Converter weighs each bit in your Binary Input by its place value and adds them up, and the total lands in Decimal Output as soon as you click Convert. When you're debugging a hex dump that's supposed to spell out a message, the hex to text converter decodes it back to readable text instantly.

Binary to Decimal Converter: Understanding Binary and Decimal Number Systems and Their Conversion Logic

The Binary Number System: Base-2 and How Each Bit Carries a Power of 2

The binary numeral system, also called base-2 or the base-2 numeral system, is a positional system that uses only two symbols: zero (0) and one (1). These two symbols, often called binary digits or bits, map directly to the on-off states of electronic components — the on state representing 1 and the off state representing 0. Because transistors and electronic circuits naturally operate in these two states, the base-2 system became the native language of all modern computers and hardware.

In the positional representation of base-2 numbers, every binary digit is weighted by a power of 2 determined by its position. The rightmost digit — called the LSB (least significant bit, or least significant digit) — carries a weight of 20 = 1. Moving left, each successive bit doubles in weight: 21 = 2, 22 = 4, 23 = 8, and so on. The high-order bit — the MSB (most significant bit, or most significant digit) — carries the highest positional value. This doubling pattern is what makes the positional method and the doubling method (double dabble) both work so elegantly.

In the base-2 system, each bit can be thought of as a switch controlling an electric signal: a high voltage is a 1 bit, a low voltage is a 0. Even the text you are reading right now is encoded as binary code at the machine language level. The decimal representation of any sequence of bits underlies everything from data processing to encoding to machine-readable storage formats. While the base-2 system has roots in ancient Egypt and ancient civilizations that used base-2 counting schemes, it found its true power in modern electronics.

Binary number example (1101):

$$1101_2 = 1 \times 2^{3} + 1 \times 2^{2} + 0 \times 2^{1} + 1 \times 2^{0} = 8 + 4 + 0 + 1 = 13_{10}$$

So the sequence 1101 has a decimal value of 13. Similarly, 1011 binary to decimal gives us 11, as we will demonstrate step by step in the conversion section.

The Decimal Number System: Base-10 Positional Notation with Powers of 10

The decimal numeral system — also called base-10 or the base 10 numeral system — is the standard numeral system of everyday life, derived from the Hindu-Arabic numeral system that uses ten symbols: 0 through 9. Each digit's contribution to a decimal number is determined by its position, which corresponds to a power of 10. This is pure positional notation, the same underlying concept as base-2, just with a different base value.

In a decimal number, the rightmost digit occupies the ones position (100 = 1), the next is the tens position (101), then the hundreds position (102), the thousands position (103), and so forth. After the decimal point, positions represent negative powers of the base: 10-1 is the tenths position, 10-2 is the hundredths position, and so on. The decimal system has been our primary counting method for centuries precisely because it aligns with human intuition built around ten fingers.

Decimal number example (123):

$$123_{10} = 1 \times 10^{2} + 2 \times 10^{1} + 3 \times 10^{0} = 100 + 20 + 3 = 123$$

The parallel with base-2 is exact: both systems use powers of the base, one uses base 10, the other uses base 2. Recognising this parallel is the key to mastering number system translation between any two numeral systems — whether that's decimal to binary, binary to hex, hex to decimal, octal to decimal, or decimal to octal.

Here is a side-by-side comparison showing the positional logic of both systems:

FeatureBinary (Base-2)Decimal (Base-10)
Base value210
Digits used0, 10–9
Positional weightPowers of 2Powers of 10
Used byComputers, electronic circuits, electronicsHumans, everyday mathematics
Example10112 = 111012310 = 123

Binary to Decimal Conversion Table: 4-Bit and 8-Bit Reference Chart

A conversion table is the fastest way to look up common values without performing any calculation. The binary to decimal conversion table below covers the full 4-bit range (0–15) with their decimal equivalents and hexadecimal (hex number) counterparts, then extends to key 8-bit milestone values up to 256. This chart is an essential reference for developers, students, and anyone working in networking or electronic systems. You can also use a decimal to binary converter to reverse the process.

Binary NumberPower of 2Decimal NumberHex Number
0000—00
00012011
00102122
001121+2033
01002244
010122+2055
011022+2166
011122+21+2077
10002388
100123+2099
101023+2110A
101123+21+2011B
110023+2212C
110123+22+2013D
111023+22+2114E
111123+22+21+2015F
00010000241610
00100000253220
01000000266440
01111111—1277F
100000002712880
11111111—255FF
10000000028256100

How to read this chart: each row shows a base-2 value, the dominant bit-weight (or combination) it encodes, its decimal equivalent, and the corresponding hexadecimal representation. Notice how the 4-bit range covers 0–15, and the 8-bit range (one full byte) covers 0–255 — the standard range for values like RGB colour channels, ASCII character codes, and IPv4 address octets. Related converters such as hex to binary, binary to ASCII, ASCII to binary, decimal to hex, and octal to decimal follow the same positional logic.

How to Convert Binary to Decimal: Step-by-Step Methods and a Free Online Tool

There are two primary methods you can use to manually translate any base-2 number into its decimal equivalent. The positional method is the most systematic, while the double dabble approach is a mental-shortcut favoured for longer sequences. For instant results without any manual calculation, a free online tool — like the binary to decimal converter on this page — handles the process automatically, even for bit strings up to 63 characters long.

Method 1: Using Positional Powers of 2 — The Standard Binary System Approach

The positional method works by assigning each bit its corresponding power of 2, then summing the results. This is the most transparent way to convert base-2 to decimal because it makes the contribution of every set bit explicit. To list powers of 2 correctly, start from the rightmost digit and assign 20, 21, 22, 23 moving left — one exponent per position. Here is the full step-by-step process using 1011 binary to decimal as our worked example, showing how to write binary number positions clearly:

  1. Step 1 — Write the binary number: Write down your base-2 number, clearly spacing each digit.
    Input: 1 0 1 1
  2. Step 2 — List powers of 2: Starting from the rightmost digit (LSB), assign increasing exponents left-ward — 20, 21, 22, 23 — so that you have one exponent per digit position.
    $$\begin{array}{cccc} 2^3 & 2^2 & 2^1 & 2^0 \\ 8 & 4 & 2 & 1 \end{array}$$
  3. Step 3 — Multiply each bit by the corresponding power of 2: Multiply every digit by its positional weight. Zero bits contribute zero value; one bits contribute their full positional value.
    $$1 \times 8 \;+\; 0 \times 4 \;+\; 1 \times 2 \;+\; 1 \times 1$$
  4. Step 4 — Add the results: Sum all products to obtain the final decimal number.
    $$8 + 0 + 2 + 1 = 11$$

Therefore, 10112 = 1110. The sum of digits weighted by their positional exponents is all it takes. You can verify this instantly with our converter above.

The general formula for any base-2 number with n digits (dn-1 … d1 d0) is:

$$\text{decimal} = d_0 \times 2^0 + d_1 \times 2^1 + d_2 \times 2^2 + \cdots + d_{n-1} \times 2^{n-1}$$

Additional examples using the same positional method:

  • 1001 binary to decimal: \(1 \times 8 + 0 \times 4 + 0 \times 2 + 1 \times 1 = 9\)
  • 1010 binary to decimal: \(1 \times 8 + 0 \times 4 + 1 \times 2 + 0 \times 1 = 10\)
  • 10101 binary to decimal: \(1 \times 16 + 0 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1 = 21\)
  • 11001 binary to decimal: \(1 \times 16 + 1 \times 8 + 0 \times 4 + 0 \times 2 + 1 \times 1 = 25\)
  • 11011 binary to decimal (also written binary 11011): \(1 \times 16 + 1 \times 8 + 0 \times 4 + 1 \times 2 + 1 \times 1 = 27\)
  • 11101 binary to decimal: \(1 \times 16 + 1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1 = 29\)
  • 11111 binary to decimal: \(1 \times 16 + 1 \times 8 + 1 \times 4 + 1 \times 2 + 1 \times 1 = 31\)
  • 111001 binary: \(1 \times 32 + 1 \times 16 + 1 \times 8 + 0 \times 4 + 0 \times 2 + 1 \times 1 = 57\)
  • 1101 binary (binary 1110010 is 114): these are confirmed by summing the relevant bit-weights.

Method 2: The Double Dabble Doubling Method

The double dabble method — also called the doubling method — is a mental-shortcut procedure that works from left to right across the bit sequence. The only rule to remember is: double the running total and add the next digit. It avoids the need to memorise exponent values, making it faster for quick translation of longer sequences in your head.

Let's apply double dabble to convert binary 1010 (1010 binary to decimal):

  1. Start: previous total = 0. Leftmost digit = 1. → \((0 \times 2) + 1 = 1\)
  2. Next digit = 0. → \((1 \times 2) + 0 = 2\)
  3. Next digit = 1. → \((2 \times 2) + 1 = 5\)
  4. Next digit = 0. → \((5 \times 2) + 0 = 10\)

Result: 10102 = 1010. Quick, clean, and no exponent lookup required. Apply the same technique to 1101: 0→1→3→6→13. So the value 1101 equals 13 in decimal — matching what the reference table above shows. The double dabble approach is especially valued in low-level development and troubleshooting scenarios where instant mental translation is needed.

How to Read a Binary Number: MSB, LSB, and Fractional Binary Numbers

To confidently translate base-2 values, you need to understand bit ordering. Every such number is read from the high-order digit (MSB — most significant digit, highest positional value) to the rightmost digit (LSB — least significant digit, 20). This is consistent with how you read a decimal number: from the highest positional value on the left to the ones place on the right.

Decimal representation of fractional numbers introduces a binary point (the base-2 equivalent of a decimal point). Every digit to the right of the radix separator represents a negative power of 2: the first position is 2-1 = 0.5, the second is 2-2 = 0.25, the third is 2-3 = 0.125, and so on. This extends the positional system concept seamlessly into non-integer values.

Fractional binary conversion example — 101.101:

$$101.101_2 = 1 \times 2^{2} + 0 \times 2^{1} + 1 \times 2^{0} + 1 \times 2^{-1} + 0 \times 2^{-2} + 1 \times 2^{-3}$$ $$= 4 + 0 + 1 + 0.5 + 0 + 0.125 = \mathbf{5.625}$$

The result is 5.625 in decimal. Each bit to the left of the separator contributes a positive integer exponent of two, while each bit to the right contributes a fractional (negative) exponent of two. Accurate translation of non-integer values requires careful attention to these negative exponents — a common source of errors in manual calculation.

Converting Binary to Decimal Using Code: Python, JavaScript, Java, and More

Every major coding language provides built-in functions for base-2 to decimal translation, handling the process automatically so you don't have to manually sum bit-weights. Below are code examples in the three most common languages, plus a note on C and the difference between unsigned and two's complement outputs.

Python: Using the int() Function

Python offers the simplest syntax for converting a bit sequence to a whole-number output via the int() function. By specifying base as 2 — i.e., int(binary_number, 2) — you instruct Python to parse the input as a base-2 number and return the corresponding decimal integer. This is an example of built-in conversion that handles any valid input sequence in a single line:

binary_number = "1101"
decimal_number = int(binary_number, 2)  # Convert binary string to decimal integer
print(decimal_number)  # Output: 13

For a more instructive approach — useful for understanding conversion techniques or building a custom script — you can write a custom function that iterates through bits manually:

def binary_to_decimal(binary_str):
    decimal_number = 0
    for i, digit in enumerate(binary_str[::-1]):
        decimal_number += int(digit) * (2 ** i)
    return decimal_number

binary_number = "1101"
print(binary_to_decimal(binary_number))  # Output: 13

This custom function iterates through bits from the rightmost digit, multiplying each bit by its corresponding positional exponent and summing the results — mirroring the manual positional method exactly. By default, Python's int() treats the input as an unsigned number (always zero or positive). Handling signed binary (two's complement) requires additional logic.

JavaScript: Using parseInt() for Quick Binary String Conversion

JavaScript provides the parseInt() function, which accepts a bit sequence and a base argument. By passing 2 as the base, the parseInt() function — also known as Integer.parseInt() in some contexts — converts a base-2 input to decimal instantly. In JavaScript, parseInt(binaryString, 2) is the standard approach:

let binaryNumber = "1011";
let decimalNumber = parseInt(binaryNumber, 2);  // Convert binary string to decimal integer
console.log(decimalNumber);  // Output: 11

Note that parseInt() in this language also returns an unsigned positive number for any valid input. If you need to handle signed numbers or two's complement results, you will need to implement additional width-aware logic in your script, checking the leading bit explicitly based on the field width of your input.

Java: Integer.parseInt() for Integer Conversion

Java uses Integer.parseInt() for base-2 translation, specifying base 2 as the second argument. Here is a complete class example demonstrating integer conversion from a bit sequence:

public class BinaryToDecimal {
    public static void main(String[] args) {
        String binaryNumber = "1011";
        int decimalNumber = Integer.parseInt(binaryNumber, 2);  // Convert binary string to decimal integer
        System.out.println(decimalNumber);  // Output: 11
    }
}

Java's Integer.parseInt() method treats the input as a positive number by default (unsigned interpretation). For signed values in a fixed-width format, Java's Byte class or manual bit manipulation is required. Java also exposes bitwise operations and shift operators (including the left shift operator <<) for low-level bit-level work, making it well-suited for system-level development tasks.

Built-in Functions for Binary to Decimal Conversion Across Languages

Here is a summary of built-in functions across popular programming languages:

  • Python: int(binary_string, 2) — specifying base as 2 triggers base-2 parsing
  • JavaScript: parseInt(binaryString, 2) — the base argument drives number system translation
  • Java: Integer.parseInt(binaryString, 2) — same pattern, returns a Java int; this Integer.parseInt() call is the idiomatic approach
  • C language: strtol(binary_string, NULL, 2) — the standard C library function strtol() handles the translation, with the third argument specifying the base

All of these leverage the concept of specifying base 2 to trigger base-2 interpretation. These automated conversion approaches are far faster and less error-prone than manual calculation for long input sequences — though understanding the underlying positional method remains essential for application development, fault-finding, and building reliable applications.

Online Binary to Decimal Converters: When to Use a Tool vs. Manual Methods

A dedicated online tool — like this one — is ideal for quick conversion of one-off calculations, verifying manual work, or handling large values (this page supports up to 63 input characters). For instant conversion in production code, the built-in conversion functions shown above are preferable. For learning, manual calculation using the positional or doubling method builds the foundational understanding that makes you a better developer and more effective at number conversion in any context.

Real-World Uses of Binary to Decimal Conversion in Computing and Digital Systems

Computing and Digital Systems: Bridging Machine-Readable and Human-Readable Data

At the heart of all modern processing, CPUs operate exclusively in base-2 — every instruction, every memory address, and every data value exists as a sequence of bits. However, the output users interact with — prices, scores, sizes, timestamps — must be human-readable decimal numbers. This translation is the mechanism that bridges these two worlds. When you're troubleshooting at a low level or analysing system performance metrics from logs, converting raw bit sequences to decimal is often the first step in making information interpretable. Electronic circuits in CPUs, GPUs, and components on every circuit board operate on base-2 logic; the translation to decimal is what makes that information actionable for engineers and users alike. This is a core concept in information technology and computing fundamentals.

Network Addressing and Configurations: Binary IP Address and Subnet Mask Calculations

In networking, IPv4 addresses are internally represented as 32-bit base-2 numbers, divided into four 8-bit octets. Each octet is a value between 0 and 255 — the full range of an 8-bit number. When you configure a router or troubleshoot a network, you work with decimal IP address notation (e.g., 192.168.1.1), but the underlying binary IP address representation drives routing decisions. Subnet mask calculations, CIDR notation, and network configuration all require converting between base-2 and decimal. Understanding that 11000000.10101000.00000001.00000001 is the binary equivalent of 192.168.1.1 is a fundamental skill for anyone working in network addressing or network security on the internet.

Data Storage and Retrieval: File Sizes, Memory Addresses, and Encoding

All data retention — whether on hard drives, SSDs, or in RAM — uses base-2 representation. File systems record sizes in base-2, but operating systems display them in decimal-friendly units like kilobytes, megabytes, and gigabytes after translation. During data retrieval, memory addresses expressed in base-2 or hexadecimal must be decoded into decimal for display and data representation in applications. The encoding of text as ASCII (where each character maps to a whole number that is held as binary code in memory), as well as image and audio content, all depend on seamless base-2 translation. Hex notation is frequently used as an intermediate step because hexadecimal compresses bit sequences by grouping 4 bits per hex digit.

Encryption and Decryption Processes: Binary in Cybersecurity and Algorithms

Modern encryption procedures — such as AES and RSA — operate on base-2 values at the bit level, performing bitwise operations, XOR transformations, and modular operations to convert plaintext into ciphertext. Cipher keys are generated and held as large base-2 numbers; decimal conversion is used to express key values in a readable format for verification and auditing. The decryption process reverses these bit-level transformations. Working knowledge of base-2 to decimal translation is therefore a core skill in cybersecurity, enabling professionals to interpret encoded output, verify key integrity, and understand how procedures manipulate and protect sensitive information. Securing information at the bit level is impossible to understand without fluency in base-2 operations.

Common Mistakes in Binary to Decimal Conversion and How to Guarantee Accurate Results

Avoiding Arithmetic Errors and Misinterpretations When You Convert Binary to Decimal

The most frequent errors in manual base-2 to decimal translation are misplacing a digit (shifting a bit one column left or right) and miscalculating exponents — for example, confusing 24 = 16 with 24 = 8. Both mistakes propagate through every subsequent addition, producing wildly incorrect decimal values. A structured approach — writing out a positional grid (23, 22, 21, 20) beneath each bit before you multiply — eliminates most of these errors. Always double-check your work by using a converter or an independent manual calculation to verify and confirm accurate conversions. Conversion accuracy matters enormously in contexts like memory addressing or cipher key interpretation, where even a single wrong bit changes the decimal value entirely.

Handling Leading Zeros and Sign Bits Correctly

Leading zeros in an input sequence do not change its numerical value: 00001011 and 1011 both equal 11 in decimal. However, handling them carelessly during translation can cause confusion, especially when comparing values of different field widths. More critically, in signed representations the high-order bit serves as the sign bit: a 0 in that position means the number is positive; a 1 means it is negative. Misreading the sign bit as a value bit leads to completely wrong results for signed numbers. Always confirm whether your input represents an unsigned or a signed number before you begin — this determines which interpretation and method is appropriate.

Unsigned vs Signed (Two's Complement) Results: How the Same Binary String Yields Different Decimal Values

The same sequence of bits can represent two entirely different decimal values depending on the interpretation. Consider the input 1101:

  • Unsigned interpretation: every bit is a set bit. Result: \(1 \times 8 + 1 \times 4 + 0 \times 2 + 1 \times 1 = 13\). The unsigned result is always zero or a positive number.
  • Two's complement (signed) interpretation — 4-bit signed format: the leading bit is the sign bit (value 1 = negative). To find the magnitude: invert bits → 0010, then add 1 → 0011 = 3. Since the sign bit is 1, the result is −3.

The field width is critical. Pad 1101 to eight bits: 00001101. Now the leading bit is 0, so both unsigned and signed two's complement interpretations give +13. This is why our converter displays the width alongside any signed result. Similarly, 11111111 in an 8-bit signed format equals −1, while its unsigned value is 255; 01111111 in the same format equals 127 (positive, since the sign bit is 0). Understanding signed number vs unsigned number conventions is essential in low-level challenges including systems development and data processing.

Binary StringBit WidthUnsigned DecimalTwo's Complement (Signed) Decimal
11014-bit signed13−3
000011018-bit signed1313
111111118-bit signed255−1
011111118-bit signed127127
100000008-bit signed128−128

Visualising the Conversion Process to Reduce Errors

One of the most effective accuracy techniques is to draw a positional grid before you begin multiplying. Write each exponent of 2 above its corresponding bit — from the high-order digit (highest power) to the rightmost digit (20) — then fill in the products row by row. This visual scaffold forces you to assign each bit to the correct digit position, preventing the most common mistake of misaligning a bit with the wrong bit-weight. It also makes the steps auditable: anyone reviewing your work can trace each multiplication back to the original input.

Best practices for consistently accurate results when you convert binary to decimal:

  • Double-check your work: always verify your manual calculation against a converter or a second independent calculation before using the result.
  • Use tools when necessary: for production code and mission-critical information, rely on built-in functions or a verified binary to decimal converter rather than mental calculation.
  • Understand the fundamentals: a solid grasp of positional notation, bit-weights, and signed vs unsigned representations prevents most misinterpretations at their source. Understand fundamentals before you automate.
  • Regular practice: working through diverse examples — whole numbers, non-integer values, signed numbers, and large bit patterns — builds conversion skills and makes errors less likely. Regular practice also improves your technical skillset and problem-solving speed for related tasks like decimal to binary, decimal to hex, and number translation in any numeral system.
  • Verify calculations at every step: in the positional method, verify each product (bit × exponent) individually before you sum the results, rather than rushing to the final addition.

Whether you are a student building translation techniques for an exam, a developer writing an application that handles base-2 input, or an engineer optimising system performance, these practices ensure your work produces efficient applications and reliable applications. Mastering the binary to decimal converter workflow — through manual calculation, code examples, and automated conversion tools — is a foundational step in any serious software engineering or information technology career.