Binary Translator

Text to binary code and binary to text as you type: paste any 0s and 1s, hex or decimal, and see each letter's bits.

UTF-8, ASCII, UTF-16 and old code pages · 7- and 8-bit groups read automatically · runs in your browser, nothing is sent

01001000 01101001

2 characters2 bytes16 bits

Try
Bytes in
HU+00487248UTF-8

Place values

1286432168421
01001000
648

64 + 8 = 72 → H

  • 1
  • 0
  • UTF-8 marker bits

Point at a character or move the caret: its bits add up below.Tap a character to see its bits add up.

Translated in your browser: nothing you type is sent anywhere.

How to use the binary translator

Type text to get binary code, or paste binary code to get text back: it translates as you type, and the pill above the result says how it read your input.

Paste binary with or without spaces, in 7-bit groups or with 0b in front; hex such as 48 69, decimal bytes such as 72 105 and code points such as U+0048 are read too. Choose binary, hex, decimal or octal output, the separator and 8 or 7 bits per byte, then copy or download it. The strip below shows every character's bytes: select one to add up its bits.

Binary translator: the word Hi as binary code 01001000 01101001, with each letter's bits and place values shownBinary translator: the word Hi as binary code 01001000 01101001, with each letter's bits and place values shownText or binaryType text or paste binary, hex or decimal: the pill says how it was read, and you can choose.The resultBinary, hex, decimal or octal, as you like it: copy it, download it or share a link.EncodingUTF-8 by default; ASCII, UTF-16 and old code pages give other bytes for the same text.The byte stripEvery character with its code point and bytes; UTF-8's marker bits in their own colour.Add up the bitsPoint at or tap a character to see its place values: 64 + 8 = 72, the letter H.
The tool as it opens, with “Hi”. Select a number to see what each part does.

How do you convert text to binary?

Look up each character's number, write the number with 8 binary digits, and join the bytes: H is 72, which is 01001000, so “Hi” is 01001000 01101001.

Computers store text as numbers from a shared table. In ASCII and UTF-8, every English letter, digit and common sign is one byte: a number from 0 to 255 written as 8 bits. To write a number in binary, split it into powers of two: 72 = 64 + 8, so the bits worth 64 and 8 are 1 and the rest are 0. Letters beyond English take 2 to 4 bytes in UTF-8.

Text to binary, step by stepUTF-8
  1. HU+0048= 720x481 byte01001000
  2. iU+0069= 1050x691 byte01101001
  3. éU+00E9= 2330xC30xA92 bytes1100001110101001

Hi01001000 01101001

H and i are ASCII, so UTF-8 writes each as one byte whose first bit is a padding 0. é is beyond ASCII: UTF-8 needs two bytes, and the marker bits (violet) say so. Source: RFC 20, RFC 3629

How do you read binary code? Binary to text, step by step

Cut the bits into groups of 8, add up the place values of the 1s (128, 64, 32, 16, 8, 4, 2, 1), and look the number up: 01001000 is 64 + 8 = 72, the letter H.

The leftmost bit of a byte is worth 128 and the rightmost 1. A byte that starts with 0 is plain ASCII; one that starts with 11 begins a longer UTF-8 character and one that starts with 10 continues it. When someone drops the leading zero you get 7-bit groups such as 1001000: this translator pads them for you, and says so when a group can't be a whole byte.

Each bit is worth twice the one to its right128 · 64 · 32 · 16 · 8 · 4 · 2 · 1
1286432168421
01001000
648

64 + 8 = 72 → H

1286432168421
01101001
643281

64 + 32 + 8 + 1 = 105 → i

01001000 01101001Hi

Add the place values of the 1s, then look the number up: 72 is H and 105 is i in ASCII, and in UTF-8, which keeps ASCII's numbers. Source: nasa.gov, RFC 20

Binary alphabet: letters A to Z in binary

Capital letters run from A = 01000001 to Z = 01011010, and small letters from a = 01100001 to z = 01111010.

A capital letter and its small letter differ in one bit, the one worth 32: A is 01000001 and a is 01100001. Digits run from 0 = 00110000 to 9 = 00111001, so their last four bits are the digit itself, and a space is 00100000. These codes are ASCII's, first published in 1963 (the small letters came in 1967), and UTF-8 kept them unchanged.

The binary alphabetASCII, written as 8-bit bytes
  1. A01000001a01100001
  2. B01000010b01100010
  3. C01000011c01100011
  4. D01000100d01100100
  5. E01000101e01100101
  6. F01000110f01100110
  7. G01000111g01100111
  8. H01001000h01101000
  9. I01001001i01101001
  10. J01001010j01101010
  11. K01001011k01101011
  12. L01001100l01101100
  13. M01001101m01101101
  1. N01001110n01101110
  2. O01001111o01101111
  3. P01010000p01110000
  4. Q01010001q01110001
  5. R01010010r01110010
  6. S01010011s01110011
  7. T01010100t01110100
  8. U01010101u01110101
  9. V01010110v01110110
  10. W01010111w01110111
  11. X01011000x01111000
  12. Y01011001y01111001
  13. Z01011010z01111010
  • The 32s bit: 0 for capitals, 1 for small letters
  • The first bit: always 0 (ASCII is 7-bit)
  • 1
A is 65 and a is 97: every capital and its small letter differ only in the bit worth 32. ASCII is a 7-bit code (0 to 127); stored in a byte, the first bit is a padding 0. Source: RFC 20

Hello, Hi and I love you in binary

“Hello” in binary is 01001000 01100101 01101100 01101100 01101111; “Hi” in binary is 01001000 01101001, and “I love you” is 01001001 00100000 01101100 01101111 01110110 01100101 00100000 01111001 01101111 01110101, spaces included.

Every English letter is one byte in ASCII and UTF-8, so a word has as many bytes as it has letters, and capitals, small letters and spaces each have their own code. “SOS” is 01010011 01001111 01010011. Type any word or name at the top to get its binary, or pick an example under the box.

Words people look up8 bits per letter
WordBinary (ASCII and UTF-8)Bits
Hi01001000 0110100116
Hello01001000 01100101 01101100 01101100 0110111140
Hello World01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 0110010088
I love you01001001 00100000 01101100 01101111 01110110 01100101 00100000 01111001 01101111 0111010180
SOS01010011 01001111 0101001124
Yes01011001 01100101 0111001124
No01001110 0110111116
OK01001111 0100101116
Love01001100 01101111 01110110 0110010132
Thank you01010100 01101000 01100001 01101110 01101011 00100000 01111001 01101111 0111010172
Computed by the translator. Every letter here is ASCII, so ASCII and UTF-8 give the same bytes; the space between words is 32, 00100000. Source: RFC 20

Why do some characters take 16, 24 or 32 bits? UTF-8 explained

UTF-8 writes English with one byte per character and everything else with two to four: é takes 2 bytes, € and most Chinese, Japanese and Korean characters 3, and emoji 4.

The first byte says how long the character is: 110 starts a 2-byte character, 1110 a 3-byte one and 11110 a 4-byte one, and every byte after it starts with 10. The remaining bits, joined, are the character's code point: é is U+00E9. One emoji you see can be several code points joined by a zero width joiner: the family 👨‍👩‍👧 takes 18 bytes. The strip at the top colours the marker bits apart from the code point's own.

UTF-8's four byte layoutsRFC 3629
  1. 1byte8 bitsAU+004141001000001U+0000 – U+007FASCII: English letters, digits, punctuation
  2. 2bytes16 bitséU+00E9C3 A9110110000111010101001U+0080 – U+07FFLatin accents, Cyrillic, Greek, Hebrew, Arabic
  3. 3bytes24 bits€U+20ACE2 82 AC11101110001010100000101010101100U+0800 – U+FFFFMost Chinese, Japanese and Korean, Indic scripts, €
  4. 4bytes32 bits😀U+1F600F0 9F 98 801111011110000101001111110100110001010000000U+10000 – U+10FFFFEmoji and other characters above U+FFFF
  • Marker bits: how many bytes, or “continues”
  • The character's own bits
  • x: a slot for the character's bits
The first byte's leading 1s count the bytes (110 = 2, 1110 = 3, 11110 = 4) and every following byte starts 10. Bytes C0, C1 and F5 to FF never appear in valid UTF-8. Source: RFC 3629

ASCII vs UTF-8 vs UTF-16: which encoding should I use?

Use UTF-8: it is the web's standard, used by about 99% of websites (W3Techs, October 2026). ASCII is its 7-bit English-only part, and UTF-16 takes two bytes for most characters.

The same word has different bits in each encoding: “Hello” is 5 bytes in UTF-8 and ASCII, 10 bytes in UTF-16 and 20 in UTF-32. A task that counts 16 bits per character means UTF-16. Older files use legacy encodings: one-byte code pages such as KOI8-R and Windows-1251 for Russian or Windows-1252 for Western Europe, and Shift_JIS for Japanese, with 2 bytes per kanji. When binary turns into strange symbols, the encoding is usually why: choose another one in the tool.

The same text in each encodingbytes, computed

“Hello” 5 characters

  • UTF-85 bytes · 40 bits
  • UTF-16BE10 bytes · 80 bits
  • UTF-32BE20 bytes · 160 bits
  • ASCII5 bytes · 40 bits
  • Windows-12525 bytes · 40 bits

“Café” 4 characters

  • UTF-85 bytes · 40 bits
  • UTF-16BE8 bytes · 64 bits
  • UTF-32BE16 bytes · 128 bits
  • ASCIIcan't write 1 character
  • Windows-12524 bytes · 32 bits

One letter, its bytes: é U+00E9

  • UTF-8C3 A9
  • UTF-16BE00 E9
  • UTF-32BE00 00 00 E9
  • Windows-1252E9
ASCII holds 128 characters (0 to 127). UTF-8 keeps ASCII at 1 byte and is used by about 99% of websites (W3Techs, October 2026); UTF-16 and UTF-32 spend 2 and 4 bytes on every Latin letter and come big- or little-endian (here big-endian). Source: webstore.ansi.org, w3techs.com, unicode.org, encoding.spec.whatwg.org

Is 65 a number or text? Decimal to binary

As a number, 65 is 1000001 in binary; typed as text it is two characters, 6 and 5, which are 00110110 00110101.

To turn a number into binary, divide it by 2 again and again and read the remainders from the last to the first: 65 gives the remainders 1, 0, 0, 0, 0, 0, 1, so 1000001. Padded to a byte that's 01000001, which is also the code of the capital A. Type a lone number at the top and you get both: its value in binary and the binary of its digits.

Two right answersthe translator shows both

65 as a number

NumberQuotientRemainder
65÷ 2 =321
32÷ 2 =160
16÷ 2 =80
8÷ 2 =40
4÷ 2 =20
2÷ 2 =10
1÷ 2 =01

Read the remainders from the bottom up: 1000001

64 + 1 = 65 · as a byte 01000001 = A

“65” as text

  1. 6U+0036 = 5400110110
  2. 5U+0035 = 5300110101

Two characters, two bytes: 00110110 00110101

Digits 0 to 9 are 48 to 57 in ASCII, so “6” is 54.

Type 65 and the result is the text's bytes; the number card under it gives 1000001, 0x41 and the letter A. Source: nasa.gov, RFC 20

How to convert text to binary in Python, JavaScript and other languages

Encode the text as UTF-8 bytes, then write each byte in base 2 with eight digits: every language has a short way to do it.

Each example here turns “Hi” into 01001000 01101001 and reads it back, and each was run to check its output. All of them use UTF-8, so the bits match this translator's; bytes written in another encoding give other bits, so use the same encoding on both sides.

Python
text = "Hi"
bits = " ".join(f"{b:08b}" for b in text.encode("utf-8"))
print(bits)
print(bytes(int(b, 2) for b in bits.split()).decode("utf-8"))
01001000 01101001 Hi

Ran on Python 3.14, October 25, 2026: prints the lines above.

JavaScript
const bits = [...new TextEncoder().encode("Hi")]
  .map((b) => b.toString(2).padStart(8, "0")).join(" ");
console.log(bits);
console.log(new TextDecoder().decode(
  Uint8Array.from(bits.split(" "), (b) => parseInt(b, 2))));
01001000 01101001 Hi

Ran on Node.js 22, October 25, 2026: prints the lines above.

Java
StringBuilder sb = new StringBuilder();
for (byte b : "Hi".getBytes(StandardCharsets.UTF_8))
    sb.append(String.format("%8s", Integer.toBinaryString(b & 0xFF))
        .replace(' ', '0')).append(' ');
String bits = sb.toString().trim();
System.out.println(bits);
String[] parts = bits.split(" ");
byte[] back = new byte[parts.length];
for (int i = 0; i < parts.length; i++) back[i] = (byte) Integer.parseInt(parts[i], 2);
System.out.println(new String(back, StandardCharsets.UTF_8));
01001000 01101001 Hi

Ran on Java 25, October 25, 2026: prints the lines above.

C# · .NET
using System.Text;

var bits = string.Join(" ", Encoding.UTF8.GetBytes("Hi")
    .Select(b => Convert.ToString(b, 2).PadLeft(8, '0')));
Console.WriteLine(bits);
Console.WriteLine(Encoding.UTF8.GetString(
    bits.Split(' ').Select(b => Convert.ToByte(b, 2)).ToArray()));
01001000 01101001 Hi

Ran on .NET 10, October 25, 2026: prints the lines above.

Go
var parts []string
for _, b := range []byte("Hi") {
	parts = append(parts, fmt.Sprintf("%08b", b))
}
bits := strings.Join(parts, " ")
fmt.Println(bits)

var back []byte
for _, p := range strings.Fields(bits) {
	n, _ := strconv.ParseUint(p, 2, 8)
	back = append(back, byte(n))
}
fmt.Println(string(back))
01001000 01101001 Hi

Ran on Go 1.25, October 25, 2026: prints the lines above.

Each snippet writes “Hi” as UTF-8 bytes in 8-bit binary. In JavaScript, String.length counts UTF-16 units (an emoji counts 2): use TextEncoder for bytes. Source: encoding.spec.whatwg.org, tc39.es

Who invented binary code?

Gottfried Leibniz described binary numbers in his 1703 paper for the Paris Academy of Sciences, but Francis Bacon had published letters written as five symbols of two kinds in 1623; the 8-bit text codes computers use grew out of ASCII (1963) and UTF-8 (1992).

Émile Baudot's telegraph code of the 1870s used five on-off units per letter. In 1974 the Arecibo radio telescope sent a picture of 1,679 bits into space, and in February 2021 NASA's Perseverance rover landed on Mars under a parachute that spells “Dare mighty things” in binary, each letter as its place in the alphabet.

Binary, 1623 to 2021to scale, 1600–2030
16001700180019002000123456789
  1. 1623

    Bacon's two-letter alphabet

    Francis Bacon writes every letter as five symbols of two kinds, a and b: 32 patterns for his 24-letter alphabet. He hinted at it in 1605 and published it in full in 1623.

    aaaaa · aaaab · aaaba · aaabb … 2⁵ = 32

    Source: archive.org

  2. 1703

    Leibniz's binary arithmetic

    Gottfried Leibniz explains counting with only 0 and 1 in his 1703 paper for the Paris Academy of Sciences.

    1 · 10 · 11 · 100 · 101 · 110 · 111

    Source: gallica.bnf.fr

  3. 1870s

    Baudot's 5-unit code

    Émile Baudot's printing telegraph sends each character as five on-off units. Its descendant, ITA2, is still an ITU-T Recommendation (S.1).

    5 → 2⁵ = 32

    Source: itu.int

  4. 1948

    “Bit”

    Claude Shannon's A Mathematical Theory of Communication uses the bit, short for binary digit, as the unit of information, and credits the word to John W. Tukey.

    bit = binary digit

    Source: people.math.harvard.edu

  5. 1956

    “Byte”

    Werner Buchholz coins the word at IBM in June 1956 for a group of 1 to 6 bits; IBM's System/360 (1964) fixes it at 8.

    1–6 bits → 8 bits

    Source: archive.computerhistory.org

  6. 1963

    ASCII

    The American Standards Association approves ASCII on June 17, 1963: 128 codes in 7 bits.

    A = 1000001

    Source: sensitiveresearch.com

  7. 1974

    The Arecibo message

    On November 16, 1974 the Arecibo telescope sends 1,679 bits into space. 1,679 = 73 × 23, two primes, so the bits fit only one grid: a picture.

    1,679 = 73 × 23

    23 × 73

    Source: news.cornell.edu

  8. 1992

    UTF-8

    Ken Thompson designs UTF-8 in September 1992, to criteria from Rob Pike, for Bell Labs' Plan 9. It keeps ASCII as 1 byte and writes any character in up to 4.

    é = 11000011 10101001

    Source: cl.cam.ac.uk

  9. 2021

    A message on Mars

    On February 18, 2021, Perseverance's parachute shows “DARE MIGHTY THINGS” in its orange and white panels: each letter its place in the alphabet, in binary (A = 1).

    DARE → 4 1 18 5 → 100 1 10010 101

    Source: photojournal.jpl.nasa.gov

Dates and numbers from primary sources. Leibniz's paper is in the Academy's volume for 1703 (printed 1705); Baudot's code is dated to the 1870s, not a year.

Binary code: questions and answers

What is binary code?

Binary code writes information with only two digits, 0 and 1, because a computer's circuits have two states, off and on. Each digit is a bit, and eight bits make a byte, a number from 0 to 255. Text becomes binary through an encoding such as ASCII or UTF-8, which gives every letter, digit and sign its own number: the capital A is 65, 01000001.

How do I translate binary to English?

Paste the binary into the box at the top: the binary decoder turns it into English text as you paste, whether the bits are spaced, run together or in 7-bit groups. By hand, cut the bits into bytes of 8, add up the place values of each byte's 1s and look the number up in the ASCII table: 01001000 is 72, the letter H, and 01101001 is 105, the letter i.

What is “hello” in binary?

With a small h, “hello” is 01101000 01100101 01101100 01101100 01101111. With a capital H, “Hello” is 01001000 01100101 01101100 01101100 01101111: only the first byte changes, in the bit worth 32. Each letter is one byte in ASCII and UTF-8, so the five letters make five bytes, 40 bits. “Hi” is 01001000 01101001.

What is “I love you” in binary?

“I love you” is 01001001 00100000 01101100 01101111 01110110 01100101 00100000 01111001 01101111 01110101. That is ten bytes: eight letters and the two spaces, each space 00100000. Written without spaces between the bytes it is one run of 80 bits, which this translator still reads, because 80 divides by 8. Type your own message at the top to get its binary.

How many bits are in one letter?

In ASCII and UTF-8, an English letter, digit or common sign is 8 bits, one byte. ASCII itself needs only 7 bits, so its bytes start with 0. In UTF-8, most accented Latin letters, such as é, and Greek, Cyrillic or Arabic letters take 16 bits; Chinese, Japanese and Korean characters, and Vietnamese letters with two marks such as ệ, usually take 24; emoji take 32. In UTF-16 most characters take 16 bits.

What does 01001000 01101001 mean?

It says “Hi”. 01001000 is 64 + 8 = 72, the capital H, and 01101001 is 64 + 32 + 8 + 1 = 105, the small i. Paste any binary into the box at the top and the translator reads it back to text, shows each byte's value, and marks any group that isn't a whole byte.

Can I paste binary without spaces?

Yes. A run of 0s and 1s is cut into bytes of 8 bits when its length divides by 8, and into 7-bit groups when it divides by 7 instead, as when every leading zero was dropped. When both work, the cut that gives readable text wins and the other is offered. Commas, new lines, bars and 0b prefixes are read too.

What does 10101 mean in binary?

As a number, 10101 is 16 + 4 + 1 = 21 in decimal. As one byte, 00010101, it is the ASCII control character NAK, which has no printed form, so it isn't a letter. Read as an ordinary decimal number instead, ten thousand one hundred and one is 10011101110101 in binary. The number card at the top gives both readings.

Why does binary turn into strange symbols like �?

Usually because the bytes were written in another encoding, or because a bit is missing. � means the bytes aren't valid UTF-8 at that point: the strip shows why, such as a continuation byte with no start or a character cut short. Older Russian files often use KOI8-R or Windows-1251, and the translator suggests one when it reads your bytes cleanly. Also check that every group has 8 bits.

Is ASCII 7-bit or 8-bit?

ASCII is a 7-bit code with 128 characters, numbered 0 to 127. Computers store each one in an 8-bit byte, so ASCII text in binary has a 0 in front: A is 1000001 in 7 bits and 01000001 in 8. The other 128 byte values belong to 8-bit code pages such as Windows-1252, or to UTF-8's longer characters.

What is 65 in binary?

The number 65 is 1000001 in binary, or 01000001 as a full byte, because 64 + 1 = 65. As a character code, 65 is the capital A in ASCII and UTF-8. The text “65”, typed as two digits, is 00110110 00110101. Type any number at the top for its binary, hex and octal forms.

Is my text sent to a server?

No. The translation runs in your browser, so what you type or paste stays on your device and is never uploaded, whichever encoding or format you choose. The address bar keeps only your settings, never your text. A link made with Copy link does carry your text in its address, so share that link only when you mean to.

Missing something?Suggest a feature or a new tool