How to Convert Octal to Binary Manually Step by Step

To convert octal to binary manually, replace each octal digit with its 3-bit binary group, then drop any leading zeros: octal 17 becomes binary 1111, and octal 755 becomes 111101101. Verify any result with our free number base converter, and use the table and examples below to make the method automatic.

Try it now: Number Base Converter →

The Octal to Binary Conversion Table: One Digit, Three Bits

The octal to binary method rests on a single fact: octal is base 8, and 8 is 2 to the power of 3, so every octal digit maps to exactly three binary bits. The table is short enough to memorize: 0 is 000, 1 is 001, 2 is 010, 3 is 011, 4 is 100, 5 is 101, 6 is 110, and 7 is 111. Notice the pattern: the three bits count upward in binary from zero to seven, and each digit's bits are just its value written in three-bit binary, with leading zeros kept inside the group. That leading-zero rule is the whole method's discipline: the digit 1 is 001, not 1, when it sits in the middle of a number, because dropping the zeros would merge groups and shift every bit that follows. Conversion is therefore not arithmetic at all but substitution: write the number, replace each digit with its three bits, and join the groups. The reverse trip groups binary bits in threes from the right, which is covered in our guide to converting binary to octal manually, and the same grouping idea in fours converts hexadecimal, as our hexadecimal to decimal guide shows from the other direction.

Method: Replace, Join, Then Drop Leading Zeros

The step-by-step method has three steps and no division. Step one: write the octal digits with a little space between them, so 755 becomes 7, 5, 5. Step two: replace each digit with its three-bit group from the table, keeping all three bits, so 7 becomes 111, 5 becomes 101, and 5 becomes 101. Step three: join the groups in order, giving 111101101, and then drop only the leading zeros at the very front of the whole number, if any. Dropping leading zeros is safe only at the front: the leading group 001 for octal 17 becomes 001111, and dropping the two front zeros leaves 1111, which is correct, but dropping zeros inside a group would change the value entirely. A good self-check is the digit count: an octal number with n digits always produces 3n bits before leading zeros are dropped, so a three-digit octal number must give nine bits, and a four-digit one must give twelve. If your answer has a different length, a group was written short. For a machine check, paste the result into our free number base converter, which converts between octal, binary, decimal, and hex in one click. The same bidirectional idea applies to text: our text to binary converter turns characters into bits, and our binary to text converter turns bits back into characters, and both are strike-list pages that searchers already find, so they are natural next steps after any base conversion.

Worked Example: Octal 17 and Octal 123

Work through octal 17 first, because it shows the leading-zero rule in action. The digits are 1 and 7. Replace 1 with 001 and 7 with 111, join them to get 001111, and drop the two leading zeros to get 1111. Check it: binary 1111 is 8 plus 4 plus 2 plus 1, which is 15, and octal 17 is one eight plus seven ones, which is also 15, so the conversion is confirmed two ways. Now octal 123, a three-digit case with no leading-zero subtlety. Replace 1 with 001, 2 with 010, and 3 with 011, join them to get 001010011, and drop the two leading zeros to get 1010011. Check it by place values: binary 1010011 is 64 plus 16 plus 2 plus 1, which is 83, and octal 123 is one 64 plus two 8s plus three ones, which is 64 plus 16 plus 3, also 83. Both examples confirm the same lesson: substitution plus a careful leading-zero trim is all the method ever needs, and the decimal cross-check catches any group written wrong.

Octal to Binary for chmod Permissions: 755 and 644

The place most people actually meet octal is Unix file permissions, where three octal digits encode read, write, and execute for owner, group, and others. Each permission digit is three bits: read is 4, write is 2, execute is 1, and the digit is their sum. Octal 755 means owner 7, group 5, others 5, and converting digit by digit gives binary 111101101, which reads as rwxr-xr-x: the owner can read, write, and execute, while group and others can read and execute but not write. Octal 644 converts to 110100100, which reads as rw-r--r--: the owner can read and write, everyone else can only read. Octal 777 is 111111111, all permissions for everyone, and octal 700 is 111000000, full access for the owner and none for anyone else. This is why chmod 755 makes a script executable and chmod 644 makes a file readable but not executable: the binary bits are the actual permission switches, and the octal digits are just a compact way to write them three at a time. If you want the text side of the same idea, our guide to converting text to binary by hand shows how characters become bits.

Binary Fractions and the Reverse Direction

Octal fractions convert with the same substitution, reading to the right of the point. Octal 0.17 becomes binary 0.001111: the digit 1 becomes 001 and the digit 7 becomes 111, joined after the point, and here trailing zeros at the far right may be dropped, while leading zeros after the point must be kept, because they are place values, not padding. The reverse direction, binary to octal, groups bits in threes starting from the point outward: for whole numbers, group from the right, padding the leftmost group with leading zeros to reach three bits, and for fractions, group from the left of the fractional part, padding the rightmost group with trailing zeros. Example: binary 111101101 groups from the right as 111, 101, 101, which is octal 755, the same permissions number from the previous section, confirming the round trip. Binary 1010011 groups from the right as 1, 010, 011, padding the first group to 001, which gives octal 123, matching the earlier example. When a binary string length is not a multiple of three, the padding side is the only decision, and it is always the outer side: left for whole numbers, right for fractions. A longer example confirms the habit: octal 7777 converts digit by digit to 111111111111, twelve bits, which is 4,095 in decimal, since octal 7777 is seven 512s plus seven 64s plus seven 8s plus seven ones, and 3,584 plus 448 plus 56 plus 7 is 4,095. Notice that 4,095 is also 2 to the power of 12 minus 1, which is exactly what twelve ones in binary represent, so the all-sevens octal number and the all-ones binary number are the same value written in two bases, a satisfying cross-check that the grouping method is sound.

5 Mistakes That Corrupt an Octal to Binary Conversion

Five mistakes corrupt almost every bad octal to binary conversion. First, writing a digit as fewer than three bits in the middle of a number, which shifts every later bit and changes the value. Second, dropping zeros inside a group instead of only at the front of the whole number, which has the same shifting effect. Third, grouping binary bits from the left instead of the right when reversing, which misaligns every group. Fourth, allowing the digits 8 or 9, which do not exist in octal: any number containing them is decimal or something else, and converting it as octal is meaningless. Fifth, confusing octal with decimal place values: octal 17 is fifteen, not seventeen, because the place values are powers of 8, not 10. The fix is a two-second audit: count your groups, confirm three bits each, confirm the total bit count is three times the digit count before trimming, and cross-check one value in decimal. Do that, and octal to binary becomes the fastest base conversion there is, because it never asks you to divide or multiply at all.