What Is a Binary to Decimal Converter?

A binary to decimal converter changes a number written in base 2 into the equivalent number written in base 10. Binary uses only two digits, 0 and 1. Decimal uses ten digits, 0 through 9. The value of a digit depends on its place. In decimal, places are powers of 10. In binary, places are powers of 2.

The converter on this page is focused on numeric conversion, not binary text decoding. If you enter 01000001 as a number, the decimal value is 65. If your goal is to decode binary bytes into letters such as ASCII text, use the binary to ASCII converter instead. Keeping these tasks separate prevents confusion: binary numbers and binary-encoded text are related, but they are not the same job.

For ordinary binary to decimal conversion, the core idea is simple. Read each binary digit as a coefficient attached to a power of 2, add the products, and write the result in decimal. For example, \(101_2\) means \(1\times2^2+0\times2^1+1\times2^0\), which equals \(5_{10}\). The subscript 2 means the number is written in base 2; the subscript 10 means the number is written in base 10.

How Binary Place Value Works

Binary place value is the foundation of every conversion. Starting from the right, the places are:

These powers evaluate to:

Each binary digit is either 0 or 1. If the digit is 1, that place value is included in the sum. If the digit is 0, that place value contributes nothing. So the binary number \(1101_2\) includes the values 8, 4, and 1, but not 2:

This is why binary is useful in computers. A bit can be off or on, false or true, 0 or 1. By arranging bits into positions, computers can represent large numbers, instructions, memory addresses, colors, characters, files, and many other kinds of data.

Binary to Decimal Formula

For an integer binary number with bits \(b_n,b_{n-1},\ldots,b_0\), the decimal value is:

Each \(b_i\) is either 0 or 1. The index \(i\) counts the place value from the right. The rightmost bit is \(i=0\), so it is multiplied by \(2^0=1\). The next bit is multiplied by \(2^1=2\). The next bit is multiplied by \(2^2=4\), and so on.

For \(10110_2\), write the places from right to left:

That same process works for every binary integer, whether the number has 3 bits or 64 bits. The only difference is the largest power of 2 used.

Step-by-Step Binary to Decimal Method

Use this method when you need to show your work in class, an exam, a worksheet, or a programming note.

Example: convert \(100101_2\) to decimal.

So \(100101_2=37_{10}\). The calculator automates the arithmetic, but the expanded method is still worth learning because it explains why the result is correct.

Quick Binary to Decimal Table

These common values help you check small binary numbers quickly.

Worked Examples

Example 1: Convert 1011 to decimal

So \(1011_2=11_{10}\).

Example 2: Convert 110010 to decimal

So \(110010_2=50_{10}\).

Example 3: Convert 10000000 to decimal

This is a useful reference value because 8-bit unsigned values run from \(00000000_2=0\) to \(11111111_2=255\).

Example 4: Convert 1110101 to decimal

When a bit is 0, its place value is skipped. That is why the \(2^3=8\) and \(2^1=2\) places do not add anything in this example.

Binary Fractions to Decimal

Binary can also represent fractions. Places to the right of the binary point use negative powers of 2:

These equal:

For example:

A binary number can have both an integer part and a fractional part. For \(101.101_2\), convert both sides of the point:

The calculator accepts one binary point for this kind of value. For very long fractions, decimal output may be rounded because decimal notation can become long, especially when displayed in a browser.

Why Binary Uses Powers of 2

Decimal uses powers of 10 because it has ten possible digit symbols. Binary uses powers of 2 because it has two possible digit symbols. This is the general rule for positional notation: in base \(b\), each place is a power of \(b\).

For binary, \(b=2\), so the places are powers of 2. For hexadecimal, \(b=16\), so the places are powers of 16. For octal, \(b=8\), so the places are powers of 8. If you need those related conversions, use the binary to hex converter, binary to octal converter, hex to decimal converter, or octal to decimal converter.

Binary is not a shortcut notation; it is a complete number system. A value such as \(1010_2\) is not "one thousand ten." It is a base-2 number equal to decimal 10. The subscript or context tells you how to read the digits.

Binary and Decimal in Computing

Computers store and process data using electronic states that can be modeled as 0 and 1. That makes binary a natural system for low-level computing. Decimal is more natural for human counting, money, measurements, and everyday arithmetic. Binary to decimal conversion bridges the two views.

For example, a byte is 8 bits. The binary byte \(01000001_2\) has decimal value 65. In an ASCII context, decimal 65 maps to the letter A. As a plain number, it is just 65. This is why the purpose of the conversion matters. Numeric conversion tells you the decimal value; text decoding requires a character encoding table.

Students studying computer science, digital electronics, networking, embedded systems, and programming often need to convert binary values by hand. If you are working with exam practice and number systems, the computer science IGCSE past papers page may be useful alongside this calculator.

Unsigned Binary Integers

An unsigned binary integer uses all bits for magnitude. A 4-bit unsigned number can represent decimal values from 0 to 15. An 8-bit unsigned number can represent decimal values from 0 to 255. In general, \(n\) bits can represent \(2^n\) different values, from 0 to \(2^n-1\).

For 8 bits:

That matches \(11111111_2=255_{10}\). For 16 bits, the maximum unsigned value is \(2^{16}-1=65535\). These values are common in programming, memory, color values, and data formats.

Signed Binary and Two's Complement

This calculator converts the binary digits as a standard unsigned positional value unless you interpret them differently. In computing, some binary patterns represent signed values using two's complement. For example, the 8-bit pattern 11111111 is 255 as an unsigned integer, but it represents -1 in 8-bit two's complement.

That difference is not a calculator error; it is an interpretation rule. The same bit pattern can have different meanings depending on the data type. If a problem says "convert binary to decimal" without mentioning signed representation, the usual classroom assumption is unsigned positional conversion. If the problem says "8-bit two's complement," you must apply the signed rule.

A practical two's complement check is this: if the leftmost bit is 0, the value is non-negative and the unsigned conversion works directly. If the leftmost bit is 1, the value is negative for a fixed-width signed interpretation. The width matters. 1111 can be 15 unsigned or -1 as 4-bit two's complement. The calculator gives the unsigned numeric value; signed interpretation should be handled according to the problem statement.

Common Mistakes When Converting Binary to Decimal

Binary to Decimal for Programming

Many programming languages support binary literals with a prefix such as 0b. For example, 0b1010 represents decimal 10 in languages that support that notation. The prefix is not part of the binary digits; it tells the language that the digits are base 2.

Programmers convert binary to decimal when checking bit masks, permissions, flags, low-level registers, networking values, color channels, embedded device settings, and file formats. A bit mask such as 00001111 has decimal value 15. A mask such as 11110000 has decimal value 240. The decimal value is sometimes easier to log or compare, while the binary form is easier for seeing which bits are set.

For broader number-base work, the binary converter and hex decimal octal binary converter are useful when you need several bases at once. This page stays focused on the direct binary-to-decimal calculation.

Binary to Decimal and Hexadecimal

Hexadecimal is often used as a compact way to write binary. One hexadecimal digit represents exactly four binary bits. For example, \(1111_2=F_{16}=15_{10}\). A byte such as \(10101100_2\) can be split into two groups of four bits: \(1010\) and \(1100\). These are A and C in hexadecimal, so the byte is \(AC_{16}\).

To convert binary directly to decimal, add powers of 2. To convert through hex, group the bits in fours, translate to hex, then convert hex to decimal if needed. Direct conversion is clearer for learning. Hex is faster for long bit patterns once you understand the grouping.

For example:

The same value is \(AC_{16}\), and \(A\times16+C=10\times16+12=172\). Both methods agree.

Binary to Decimal and Octal

Octal uses base 8, and each octal digit represents three binary bits. For example, \(111_2=7_8=7_{10}\). Octal is less common than hexadecimal in modern everyday computing, but it still appears in some programming and permission contexts.

For a binary number such as \(110101_2\), direct decimal conversion gives:

Grouped into three-bit chunks, \(110101_2=65_8\). Convert octal 65 to decimal:

Again, both methods give the same result. Use the method that fits the question. If the question asks for binary to decimal, the direct power-of-2 method is usually the clearest answer.

Long Binary Numbers

Long binary numbers are easier to convert with a calculator, but the same place-value logic applies. For manual checking, group bits into fours from the right. This does not change the value; it only makes the number easier to read. For example:

Each group \(1111_2\) is 15, so the hexadecimal form is \(FFF_{16}\). In decimal, the value is:

The shortcut works because a sequence of \(n\) ones in binary equals \(2^n-1\). For 8 ones, the value is \(2^8-1=255\). For 16 ones, it is \(2^{16}-1=65535\). This is a useful pattern for checking maximum unsigned values.

Leading Zeros in Binary

Leading zeros do not change the numeric value of an unsigned binary number. \(101_2\), \(0101_2\), and \(00000101_2\) all equal decimal 5. Leading zeros are still useful because they show fixed width. A byte is usually shown with 8 bits, so decimal 5 may be written as \(00000101_2\) when byte width matters.

Fixed width is important in computing. It tells you how many bits are stored, transmitted, or interpreted. It also matters for signed numbers. \(1000_2\) is 8 as an unsigned 4-bit number, but it can represent -8 in 4-bit two's complement. The digits alone are not always enough; the representation rule matters.

Binary Fractions and Rounding

Some binary fractions convert cleanly to decimal. For example, \(0.1_2=0.5_{10}\) and \(0.01_2=0.25_{10}\). Binary fractions are based on halves, quarters, eighths, sixteenths, and so on. Decimal fractions are based on tenths, hundredths, thousandths, and so on. Because the bases are different, some values that are simple in one base can be long in the other.

The binary fraction \(0.0001_2\) equals \(1/16=0.0625_{10}\). The binary fraction \(0.001_2\) equals \(1/8=0.125_{10}\). These are exact because powers of 2 divide neatly into these decimal forms. For longer binary fractions, the decimal output can contain many digits. The calculator gives a practical decimal display, but in formal work you may need exact fractional notation.

For example:

If a binary fraction is part of a programming or floating-point question, remember that computer floating-point representation has its own rules. This page explains base conversion, not every detail of binary floating-point formats.

Checking Your Answer

A strong conversion should be easy to verify. First, estimate the range. If a binary number has \(n\) bits and the leftmost bit is 1, the value is at least \(2^{n-1}\) and less than \(2^n\). For example, any 8-bit number starting with 1 is at least 128 and at most 255 if interpreted as unsigned.

Second, convert back if needed. If \(101101_2=45_{10}\), then decimal 45 should convert back to binary 101101. The reverse process is a separate skill, and the decimal to binary converter is the focused tool for that direction.

Third, compare with known powers of 2. If the binary number is \(100000_2\), the decimal result must be a power of 2. Specifically, \(100000_2=2^5=32\). A result such as 64 would mean the exponent was counted one place too high.

Practice Questions

Try converting these before checking the answer column.

Using Binary to Decimal in Spreadsheets

Spreadsheets can store binary values as text or numbers. Treat binary inputs as text when leading zeros matter. If a spreadsheet interprets \(00001010\) as the number 1010, it may remove leading zeros and make the bit width unclear. A text column preserves the exact bit pattern.

When documenting spreadsheet conversions, keep one column for the original binary text and one column for the decimal result. Add a heading such as "Binary input" and "Decimal output." If the data includes signed values, include another column for representation, such as "unsigned" or "8-bit two's complement." Without that context, the same bits can be interpreted differently.

For general numeric work beyond binary conversion, the math calculator, scientific calculator, and log base 2 calculator can support related checks involving powers, exponents, and logs.

Binary to Decimal for Students

Students often make faster progress when they memorize the first few powers of 2. These are the building blocks of binary conversion:

Once these values are familiar, converting binary becomes a pattern-recognition task. For example, \(101010_2\) uses 32, 8, and 2, so the result is 42. You do not need to rederive every power if the common values are already known.

However, memorization should not replace understanding. Always know why the rightmost bit is \(2^0\) and why each move left doubles the place value. That principle applies across all positional number systems, not only binary.

Left-to-Right Doubling Method

The place-value method is the clearest way to learn binary, but there is another efficient method for hand conversion: scan the binary number from left to right, double the running total, then add the next bit. This works because moving one place to the right in a base-2 number is equivalent to multiplying the value built so far by 2.

For example, convert \(110101_2\) using the doubling method:

So \(110101_2=53_{10}\). The same answer comes from place value: \(32+16+0+4+0+1=53\). The doubling method is useful for long strings because it avoids writing every power of 2. The place-value method is better when you need to show exactly which powers are included. Both methods are valid because both come from positional notation.

Bit Weight Table up to 16 Bits

When converting by hand, a bit-weight table saves time. The rightmost bit has weight 1. Each move left doubles the weight. A 16-bit unsigned integer uses weights from \(2^0\) through \(2^{15}\).

For a 16-bit value such as \(1000000000000000_2\), the decimal value is 32768. For \(1111111111111111_2\), the decimal value is \(2^{16}-1=65535\). These reference points are useful in programming, networking, and digital electronics.

Bytes, Nibbles, and Binary Groups

Binary numbers are often grouped to improve readability. A nibble is 4 bits. A byte is 8 bits. Grouping a long binary number into nibbles makes it easier to convert to hexadecimal, while grouping into bytes makes it easier to read memory, ASCII values, color channels, and network data.

For example, the byte \(01101010_2\) can be read by place value:

The same byte can be split into nibbles: \(0110\;1010_2\). The first nibble \(0110_2\) is 6, and the second nibble \(1010_2\) is 10, which is A in hexadecimal. The hexadecimal form is \(6A_{16}\), and \(6\times16+10=106\). Grouping does not change the number; it only makes conversion and checking easier.

If your goal is to convert binary to another base rather than decimal, use the focused pages for binary to hexadecimal or binary to octal. If you need to convert several bases in one place, the ASCII, hex, binary, decimal, Base64 converter can support broader conversion work.

Binary to Decimal in Networking

Networking uses binary values constantly, even when humans usually see decimal notation. IPv4 addresses are commonly written as four decimal octets, but each octet is an 8-bit binary value. For example, the binary octet \(11000000_2\) equals 192 in decimal:

The octet \(10101000_2\) equals 168:

That is why a familiar address beginning with 192.168 can be represented internally as binary octets. Subnet masks also rely on binary patterns. For example, \(11111111_2=255_{10}\), so an octet with all bits set appears as 255 in dotted decimal notation.

When converting binary octets, keep exactly eight bits if the width matters. \(1_2\) and \(00000001_2\) both equal decimal 1, but the second form makes clear that the value is one byte wide. Fixed width is important in networking because each octet has eight positions, even when leading zeros are present.

Binary to Decimal for Bit Masks and Flags

A bit mask is a binary pattern used to select, set, clear, or test specific bits. In programming, masks are often shown in binary for readability but stored or logged in decimal or hexadecimal. Converting the binary pattern to decimal helps when an API, configuration file, or database expects a decimal value.

For example, the mask \(00001111_2\) has the lower four bits set:

The mask \(11110000_2\) has the upper four bits set:

Seeing the same value in binary and decimal helps avoid mistakes. Decimal 240 alone does not show which bits are set. Binary \(11110000_2\) shows the pattern immediately. The best representation depends on whether you are doing arithmetic, reading bits, or communicating with a system that expects a specific format.

Binary to Decimal in File and Data Formats

File formats often describe values as bytes, bit fields, flags, and offsets. A specification may say that a particular byte uses binary flags, while a debugging tool may show the same byte as a decimal number. Binary to decimal conversion helps connect the specification with the observed value.

Suppose a byte is shown as decimal 13. Convert decimal 13 back to binary and you get \(00001101_2\). That means the 8, 4, and 1 bits are set. If the file format says those bits represent three different options, the decimal value alone is not enough to understand the state. The binary form explains which flags are active.

This page focuses on binary to decimal. When you need the reverse direction during data inspection, use the decimal to binary converter. Keeping the direction clear helps avoid turning a decimal value into another decimal-looking string by accident.

Troubleshooting Invalid Binary Input

A binary number can contain only 0 and 1, plus an optional binary point if fractions are allowed. Digits such as 2, 3, 8, or 9 are not valid binary digits. A string such as 10201 may look numeric, but it is not a valid base-2 number. The converter rejects it because the digit 2 has no place in binary notation.

Spaces and underscores are often used to make long binary values readable. For example, 1111_0000 and 1111 0000 are readable groupings of the same bit pattern. This calculator ignores spaces and underscores, so grouped input can still be converted. Other punctuation, letters, and multiple decimal points should be removed unless a specific programming language notation requires them.

Do not include a prefix such as 0b in the calculator unless the tool specifically allows it. The mathematical binary digits are the 0s and 1s after the prefix. If you see 0b101101 in code, enter 101101 here. The prefix tells a programming language that the literal is binary; it is not part of the value's digit expansion.

Large Binary Numbers and Exactness

Large binary integers can exceed the safe integer range of ordinary floating-point arithmetic in some programming environments. The calculator uses integer-safe logic for whole binary inputs, so long integer strings can still be converted without relying on a floating-point approximation. Fractional binary values may require decimal rounding in display because finite browser number formats have practical limits.

For example, a 64-bit pattern may represent a very large unsigned integer. It is still converted by the same formula:

The formula is not different for large values; there are simply more terms. For learning and checking, break long numbers into groups of four or eight bits. This makes errors easier to find. If one group is copied incorrectly, the final decimal value can change dramatically.

When exactness matters in a programming workflow, keep the original binary string as text. Do not convert a long identifier, mask, or bit field into a decimal number and then discard the original. The decimal result is useful, but the binary pattern may contain structural information that the decimal form hides.

Binary Numbers Versus Binary Text

Binary-to-decimal conversion answers the question, "What is the base-10 value of this base-2 number?" Binary-to-text conversion answers a different question: "What characters do these bits represent under a chosen encoding?" The same bit pattern may be meaningful in both ways, but the output is different.

For example, \(01001000_2\) is 72 in decimal. Under ASCII, decimal 72 represents the uppercase letter H. A numeric converter should return 72. A text decoder should return H. Neither answer is wrong; they answer different questions.

If you are working with text, use a text-focused tool such as the binary to string converter, ASCII text to binary converter, or binary to ASCII page. If you are working with numeric base conversion, stay on this binary to decimal converter.

Relating Binary, Decimal, Octal, and Hex

Binary, decimal, octal, and hexadecimal are all positional number systems. They differ in base, digit set, and grouping convenience. Binary is base 2 and uses 0 and 1. Octal is base 8 and uses digits 0 through 7. Decimal is base 10 and uses digits 0 through 9. Hexadecimal is base 16 and uses digits 0 through 9 plus A through F.

The same value can be written in each base:

Each form is useful in a different context. Binary shows individual bits. Octal groups bits in threes. Hex groups bits in fours. Decimal is easiest for most human arithmetic. If you need to move from decimal to other bases after converting, the decimal to hex converter and decimal to octal converter handle those specific directions.

Number System Learning Path

A practical learning path is to start with unsigned binary integers, then binary fractions, then hexadecimal grouping, then signed binary representation. Each topic builds on the same place-value foundation. Do not start with two's complement or floating-point details until ordinary base-2 conversion is comfortable.

First, memorize powers of 2 up to at least 1024. Second, practice converting 4-bit and 8-bit numbers. Third, learn how leading zeros preserve width. Fourth, learn how nibbles map to hexadecimal digits. Fifth, study signed representation rules only after the unsigned method is reliable. This sequence keeps the ideas separate and reduces mistakes.

For a broader overview of number-base tools, use the number conversion page or the general converters directory. Use this page when the task is specifically binary to decimal.

Exam-Style Working for Binary to Decimal

In school and exam settings, the final decimal answer is not always enough. A clear method can earn marks even if a small arithmetic error appears later. The safest written layout is to place each binary digit above its power of 2, then write the sum of the active place values.

For example, convert \(101011_2\):

This answer is easy to follow because every bit has been accounted for. The zeros are included in the first line so the reader can see that the \(2^4\) and \(2^2\) places were checked rather than forgotten. In a shorter solution, you can write only the active values:

Both styles are correct. The expanded style is better when learning or showing formal working. The shorter style is better once the method is secure and the question does not require every place value to be displayed.

Place-Value Audit Checklist

A place-value audit is a quick review of the conversion before you trust the answer. Start by counting the bits. A 6-bit unsigned number must be between 0 and 63 because \(2^6-1=63\). If your decimal result for a 6-bit binary number is 95, something is wrong. A 10-bit unsigned number must be between 0 and 1023. A 12-bit unsigned number must be between 0 and 4095.

Next, check the leftmost bit. If the leftmost bit is 1 in an unsigned integer with \(n\) bits, the value is at least \(2^{n-1}\). For example, an 8-bit number starting with 1 is at least 128. If \(10011010_2\) converts to a result below 128, the highest place value was probably missed. If an 8-bit unsigned result is above 255, too many place values were added.

Finally, check the rightmost bit. If the rightmost bit is 1, the decimal result must be odd. If the rightmost bit is 0, the decimal result must be even. This parity check catches many small errors. For example, \(101100_2\) ends in 0, so the decimal result must be even. If your answer is 45, review the final place because the correct value is \(32+8+4=44\).

Binary Point Versus Decimal Point

People often say "decimal point" for the dot in any number, but in a binary number the dot is more precisely a binary point. It separates positive powers of 2 on the left from negative powers of 2 on the right. The notation looks familiar, but the place values are different from decimal fractions.

In decimal, \(0.1_{10}\) means one tenth. In binary, \(0.1_2\) means one half:

In decimal, \(0.01_{10}\) means one hundredth. In binary, \(0.01_2\) means one quarter:

This difference is important in programming and digital systems. A binary fraction is not read digit by digit as a decimal fraction. It must be converted using negative powers of 2. A value such as \(10.01_2\) equals \(2.25_{10}\), not ten point zero one.

More Binary Fraction Examples

Binary fractions become easier after a few examples. Convert \(11.01_2\):

Convert \(1001.011_2\):

Convert \(0.1111_2\):

These examples show a pattern: binary fractional places halve each time as you move right. If the first fractional bit is 1, add 0.5. If the second is 1, add 0.25. If the third is 1, add 0.125. If the fourth is 1, add 0.0625.

Copying Binary Values Correctly

Binary strings are easy to mistype because they contain repeated 0s and 1s. When copying a long value, group the digits before converting. Groups of four are common because they map neatly to hexadecimal. Groups of eight are common because they map to bytes. For example, write 11001010 01110100 rather than 1100101001110100 when readability matters.

If a source uses separators, check whether the separator is part of the notation or only visual grouping. Spaces and underscores usually group digits. A dot may be a binary point, so it changes the value. A comma may be a formatting mark in prose, not part of the number. When preparing clean input for a calculator, remove visual separators but keep a real binary point if the value is fractional.

After conversion, keep the original binary value beside the decimal output. A decimal number alone hides the bit pattern. This matters in programming notes, debugging records, networking examples, and classroom answers where the structure of the bits is part of the explanation.

Binary to Decimal Versus Binary Arithmetic

Converting binary to decimal is not the same as doing arithmetic directly in binary. If the question only asks for the decimal value, convert the number using place value. If the question asks you to add, subtract, multiply, or divide binary numbers, you may need binary arithmetic rules or you may convert to decimal, perform the operation, and convert back depending on the instructions.

For example, \(101_2+11_2\) can be handled directly in binary or through decimal. Directly, the sum is \(1000_2\). Through decimal, \(101_2=5\) and \(11_2=3\), so the sum is \(8\), which is \(1000_2\). Both routes agree. If you are checking base arithmetic, a calculator can help verify the value, but it should not replace understanding of the method required by the task.

For wider base conversions beyond this single direction, use the general unit converters collection or the focused number conversion pages already linked above. Each page should answer its own conversion direction clearly.

Final Review Before Using a Decimal Result

Before using a converted decimal value, check four things. First, confirm the input contains only binary digits. Second, confirm whether the value is meant to be unsigned, signed, fractional, or text encoded. Third, check the expected range based on the number of bits. Fourth, label the result clearly as base 10.

A clear final line looks like this:

This format preserves both the source base and the target base. It is concise enough for calculator output and precise enough for student work, programming notes, and technical explanations.

Frequently Asked Questions