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.
Place values
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.

Text 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.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.
- HU+0048= 720x481 byte01001000
- iU+0069= 1050x691 byte01101001
- éU+00E9= 2330xC30xA92 bytes1100001110101001
Hi01001000 01101001
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.
64 + 8 = 72 → H
64 + 32 + 8 + 1 = 105 → i
01001000 01101001Hi
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.
- A01000001a01100001
- B01000010b01100010
- C01000011c01100011
- D01000100d01100100
- E01000101e01100101
- F01000110f01100110
- G01000111g01100111
- H01001000h01101000
- I01001001i01101001
- J01001010j01101010
- K01001011k01101011
- L01001100l01101100
- M01001101m01101101
- N01001110n01101110
- O01001111o01101111
- P01010000p01110000
- Q01010001q01110001
- R01010010r01110010
- S01010011s01110011
- T01010100t01110100
- U01010101u01110101
- V01010110v01110110
- W01010111w01110111
- X01011000x01111000
- Y01011001y01111001
- Z01011010z01111010
- The 32s bit: 0 for capitals, 1 for small letters
- The first bit: always 0 (ASCII is 7-bit)
- 1
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.
| Word | Binary (ASCII and UTF-8) | Bits |
|---|---|---|
| Hi | 01001000 01101001 | 16 |
| Hello | 01001000 01100101 01101100 01101100 01101111 | 40 |
| Hello World | 01001000 01100101 01101100 01101100 01101111 00100000 01010111 01101111 01110010 01101100 01100100 | 88 |
| I love you | 01001001 00100000 01101100 01101111 01110110 01100101 00100000 01111001 01101111 01110101 | 80 |
| SOS | 01010011 01001111 01010011 | 24 |
| Yes | 01011001 01100101 01110011 | 24 |
| No | 01001110 01101111 | 16 |
| OK | 01001111 01001011 | 16 |
| Love | 01001100 01101111 01110110 01100101 | 32 |
| Thank you | 01010100 01101000 01100001 01101110 01101011 00100000 01111001 01101111 01110101 | 72 |
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.
- 1byte8 bitsAU+004141001000001U+0000 – U+007FASCII: English letters, digits, punctuation
- 2bytes16 bitséU+00E9C3 A9110110000111010101001U+0080 – U+07FFLatin accents, Cyrillic, Greek, Hebrew, Arabic
- 3bytes24 bits€U+20ACE2 82 AC11101110001010100000101010101100U+0800 – U+FFFFMost Chinese, Japanese and Korean, Indic scripts, €
- 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
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.
“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
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.
65 as a number
| Number | Quotient | Remainder | |
|---|---|---|---|
| 65 | ÷ 2 = | 32 | 1 |
| 32 | ÷ 2 = | 16 | 0 |
| 16 | ÷ 2 = | 8 | 0 |
| 8 | ÷ 2 = | 4 | 0 |
| 4 | ÷ 2 = | 2 | 0 |
| 2 | ÷ 2 = | 1 | 0 |
| 1 | ÷ 2 = | 0 | 1 |
Read the remainders from the bottom up: 1000001
64 + 1 = 65 · as a byte 01000001 = A
“65” as text
- 6U+0036 = 5400110110
- 5U+0035 = 5300110101
Two characters, two bytes: 00110110 00110101
Digits 0 to 9 are 48 to 57 in ASCII, so “6” is 54.
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.
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"))
Ran on Python 3.14, October 25, 2026: prints the lines above.
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))));
Ran on Node.js 22, October 25, 2026: prints the lines above.
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));
Ran on Java 25, October 25, 2026: prints the lines above.
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()));
Ran on .NET 10, October 25, 2026: prints the lines above.
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))
Ran on Go 1.25, October 25, 2026: prints the lines above.
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.
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
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
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
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
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
1963
ASCII
The American Standards Association approves ASCII on June 17, 1963: 128 codes in 7 bits.
A = 1000001
Source: sensitiveresearch.com
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 × 73Source: news.cornell.edu
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
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
Binary code: questions and answers
What is binary code?
How do I translate binary to English?
What is “hello” in binary?
What is “I love you” in binary?
How many bits are in one letter?
What does 01001000 01101001 mean?
Can I paste binary without spaces?
What does 10101 mean in binary?
Why does binary turn into strange symbols like �?
Is ASCII 7-bit or 8-bit?
What is 65 in binary?
Is my text sent to a server?
Missing something?Suggest a feature or a new tool
Related tools
Morse Code Translator
Text to Morse and back, played as sound, light or vibration, and decoded from audio or a photo
Small Text Generator
Convert text to 44 Unicode font styles — tiny text, bold, italic, script, fraktur & more
Invisible Character
Copy and paste an invisible character or blank space, and find or remove hidden characters in text
IP to Decimal Converter
IP address to decimal, hex, binary and octal and back, with each octet's place values
Subnet Calculator
Network, broadcast, usable hosts and masks for any IPv4 or IPv6 block, plus VLSM, splits and cloud subnets
UUID Generator
Generate UUID v4, v7, v1, v5 and v3 or GUIDs in bulk, in any format, and decode a UUID's version and timestamp