Text to Binary Converter

This converter turns characters into 8-bit UTF-8 or ASCII bytes. If you have ASCII decimal codes rather than characters, use ASCII to Binary; for a plain number, use Decimal to Binary.

Going the other way? Convert binary back to text →

How do you convert text to binary?

Text to binary conversion replaces every character with the 8-bit binary form of its ASCII or UTF-8 code, so a two-letter word becomes two groups of eight digits.

1. Take the first character and look up its code. H is 72.
2. Convert that code to binary by repeated division or from the table. 72 is 1001000.
3. Pad the result on the left with zeros until it is 8 digits: 01001000.
4. Repeat for every character and separate the bytes with a single space: Hi = 01001000 01101001.

Text to Binary Conversion Table

Every letter, digit and the space, with its code in all four bases. Find the character in the first column and read across: the Dec column is the code the method uses, and the Bin column is what this converter writes — 8 digits per character, zero-padded on the left. That column uses the digit set 0, 1 and nothing else, each place worth 2ⁿ, and a value marked with the 0b prefix means the same thing. This page writes one 8-bit zero-padded byte per character, single space between bytes. This page shows the rows you need; ASCII code chart (decimal, hex, octal, binary) carries all 128.

The base this page writes, defined by the digits it uses, how a value is marked, and what each position is worth.

Worked Example: "Hi" to Binary

One character at a time, with the working written out. This is the same grid the converter shows when you turn on "show steps".

Take the first character, H. Its code is 72. Written in binary that is 1001000, which is 8 digits only once a leading zero is added: 01001000. The place values across the top of the grid show why — 64 + 8 = 72, and every column with a 1 in it contributes its own weight.

Every remaining character repeats that same three moves: find the code, write it in binary, pad it to 8 digits. i is 105, so 01101001. The groups then join in the order the characters were typed, separated by a single space.

Nothing about the order or the count changes: one character in, one group out. That is what makes the result reversible without carrying any extra information alongside it, and it is also the quickest way to check the answer. Count the groups; there should be exactly as many as there are characters, spaces included. Then take any one group and find its row in the table above — the code in the Dec column must be the number in the Code column of the grid, and the Binary column must be the group itself. A group that comes out one digit short means a leading zero was dropped; a group count that is short means a space was trimmed off the input before the conversion ran. Those two are the only ways a correct code still produces a wrong-looking result.

Check it in reverse

The value goes back the way it came. Read 01001000 is 72, and 72 is H; read 01101001 is 105, and 105 is i. Nothing is lost on the return trip, because every character keeps one group of its own and the groups keep their order. A decoder needs no extra information from the encoder — the fixed width tells it where each group ends, and the table tells it what each code means. To verify the result by hand, decode the binary output back to text and compare it with what you started from.

Worked examples: text to binary

Each example gives the value first, then the working. Click a value to load it in the converter.

Common phrases people convert: what binary code is · load one of these into the decoder

Every example above reverses exactly — decode the same 8-bit groups back into words.

What Changes the Binary Output?

Spaces and line breaks

A space is a character like any other: code 32, or 00100000. A trailing space converts too, which is the usual reason an output runs one group longer than expected.

Characters outside ASCII

UTF-8 encodes each character in 1 to 4 bytes. Characters 0–127 use one byte identical to ASCII, so ASCII text is valid UTF-8. Above code 127 UTF-8 uses more than one byte per character, so the byte count stops matching the character count. é is U+00E9 and encodes as C3 A9 (2 bytes); € is U+20AC and encodes as E2 82 AC (3 bytes); 😀 is U+1F600 and encodes as F0 9F 98 80 (4 bytes). Written the way this page writes them, those are é = 11000011 10101001, € = 11100010 10000010 10101100 and 😀 = 11110000 10011111 10011000 10000000. UTF-8 encoding explained sets out why.

Width and padding

ASCII defines 128 characters, codes 0–127, using 7 bits; in practice each code is stored in one 8-bit byte with a leading 0. That is why A is 01000001 here, not 1000001. Uppercase and lowercase differ by 32, which is bit 5, so a is 01100001.

Separator choice

The space between groups is a display choice; the bytes do not change. iToolHub's text-to-binary and text-to-hex converters write one 8-bit byte per character, separated by spaces. Pick no separator when the output feeds another program, a comma for a spreadsheet.

Text to Binary in Code

The same rule in one line. Both take a string and return the binary codes, space-separated.

Python: ' '.join(format(b, '08b') for b in s.encode('utf-8'))

JavaScript: [...new TextEncoder().encode(s)].map(b => b.toString(2).padStart(8, '0')).join(' ')

Common Mistakes

• Dropping the leading zero, so A reads 1000001 instead of 01000001. The output then splits into the wrong groups.
• Mixing widths inside one string. The first half decodes; the rest is noise.
• Pasting codes instead of characters — that is a different conversion, and it lives on convert an ASCII code (0–127) to binary.
• Forgetting that the space between words is its own group, 00100000. The counts then disagree.

Frequently Asked Questions

Related Conversions

• Input in ASCII codes instead? convert an ASCII code (0–127) to binary.
• To ASCII codes by the same route — find the ASCII code value of any letter.
• To hex by the same route — text to hex (UTF-8).
• To octal by the same route — octal escape code for each character.
• Input in decimal instead? decimal to binary by repeated division.
• Input in hex instead? hexadecimal to binary.

The rest of the family sits on the rest of the binary converters in this family.