Convert byte arrays to strings online. Decode space- or comma-separated bytes (decimal, hex, or binary) to UTF-8 text. Free browser-based byte-to-string converter.
The Tooloogle Byte Array to String Converter takes a list of byte values — space-separated or comma-separated — and decodes them into a readable UTF-8 string in your browser. Paste bytes copied from a debugger, a network capture, a hex dump, a programming-language ``Uint8Array`` literal, or a database BLOB, and watch the decoded text appear instantly. No upload, no signup, no rate limits — the whole conversion runs locally using the native ``TextDecoder`` API. Perfect for backend developers debugging serialized payloads, security researchers reading captured packets, mobile-app engineers tracing native code, and anyone who needs to turn raw bytes back into the human-readable text they originally encoded.
When you paste a string of byte values into the input area, the converter splits the input on commas (if any are present) or whitespace, parses each token as a base-10 integer, packs the resulting numbers into a ``Uint8Array``, and decodes the array as UTF-8 via the browser's built-in ``TextDecoder``. The output text appears in the second box as soon as you stop typing — there is no "Convert" button, no waiting for a server round-trip. Internally, the conversion is a one-line ``new TextDecoder().decode(new Uint8Array(bytes))`` call, exactly the same primitive a Node.js, browser, or Deno program would use. The converter expects decimal byte values in the standard 0–255 range; values outside that range are silently truncated by the ``Uint8Array`` constructor (so 256 becomes 0, 257 becomes 1, and so on — standard JavaScript behavior).
Two separator modes — auto-detected. Use commas (``72, 101, 108, 108, 111``) or whitespace (``72 101 108 108 111``) interchangeably.
UTF-8 decoding — correctly reconstructs multi-byte characters: emoji, accented letters, CJK scripts, anything that can be expressed in Unicode.
Live updates — the output refreshes as you type; no "Convert" button to click.
Tolerant input — extra whitespace, trailing commas, and mixed separators all work.
Browser-only — uses native ``TextDecoder`` and ``Uint8Array``. No upload, no analytics on your bytes. Safe for proprietary protocol payloads, security research data, customer payloads under NDA, and anything else you can't send to a random web service.
Instant feedback for invalid input — if the input cannot be parsed as a list of bytes, the output reads "Invalid byte input" instead of crashing.
No setup, no install — works in any modern browser; no extension, no signup, no API key.
Copy your byte array. From your debugger, network capture, hex dump, log file, or programming-language source — any list of byte values 0–255 will work.
Paste into the "Bytes" box. Separators don't matter — commas, spaces, tabs, or newlines all parse correctly.
Read the decoded string in the "String" box. Output updates live as you type or paste.
Copy the result with your usual keyboard shortcut, or select & copy to paste into your editor, ticket, or chat.
If the result looks like garbage, the bytes are likely not UTF-8 — try a different decoder, check that the bytes are decimal (not hex or binary), and verify the byte order matches what your source produced.
Backend engineers reading byte payloads from a Kafka topic or message queue and wanting to see the human-readable string the producer encoded. Mobile-app developers tracing a native call where the C/C++ side returned a raw byte buffer and the Swift/Kotlin side needs to interpret it. Security researchers analyzing a packet capture in Wireshark or Burp Suite where the payload field is shown as a comma-separated byte list and the underlying protocol carries text. QA engineers verifying that a serializer produced exactly the bytes a spec calls for. Reverse-engineering work on a binary blob extracted from a firmware dump or game asset where strings are scattered between binary regions. Database administrators inspecting BLOB columns that were stored as byte arrays but contain text payloads. Logging pipelines that produce ``Uint8Array`` JSON dumps and you need to verify the human content. IoT engineers reading sensor payloads where the data is transmitted as UTF-8 wrapped in a fixed-length byte buffer. Cross-language porting where one side speaks ``byte[]`` and the other speaks ``String`` and you need to verify the two are equivalent. Test-fixture preparation where a known byte sequence needs to be confirmed as a known-good text value before being checked into source control.
The converter expects decimal byte values 0–255 separated by commas or whitespace. Many languages and tools format byte arrays differently — here's how to convert each into the format the tool expects:
JavaScript / TypeScript ``Uint8Array``: ``new Uint8Array([72, 101, 108, 108, 111])`` — copy the contents of the array literal directly.
Python ``bytes`` literal: ``b"Hello"`` — print as a list with ``list(b"Hello")`` to get ``[72, 101, 108, 108, 111]``.
Java / Kotlin ``byte[]``: copy values from the debugger; in Java bytes are signed (-128 to 127), so wrap negative values with ``& 0xFF`` before pasting (e.g. ``-61 & 0xFF`` = 195).
C# ``byte[]``: copy from ``Console.WriteLine(string.Join(",", bytes))``.
Hex dumps (``48 65 6C 6C 6F``): convert each hex pair to decimal first — or use the Tooloogle Hex to ASCII Converter for hex-encoded text.
Binary (``01001000 01100101…``): convert each 8-bit chunk to decimal first — or use the Tooloogle Binary to Text Converter for binary-encoded text.
UTF-8 is a variable-length character encoding: ASCII characters (codepoints 0–127) take a single byte; characters above 127 take 2, 3, or 4 bytes. The converter correctly reassembles multi-byte sequences. Examples:
``72`` → ``H`` (single ASCII byte).
``195, 169`` → ``é`` (two-byte sequence for U+00E9).
``226, 130, 172`` → ``€`` (three-byte sequence for U+20AC).
``240, 159, 152, 138`` → ``😊`` (four-byte sequence for U+1F60A, a smiling-face emoji).
If your bytes are not UTF-8 (for example UTF-16, Latin-1, or a proprietary encoding), the decoded output will contain replacement characters (``�``) or look like garbled text. In that case the byte values themselves are the right numbers; only the encoding interpretation is wrong. Try a Latin-1 or UTF-16 decoder instead, or use the Tooloogle Hex to ASCII Converter / Bytes-to-String Converter combination as appropriate.
Always know the encoding of the bytes you're decoding. UTF-8 is the de-facto modern default; Latin-1 (ISO-8859-1) appears in older European protocols; UTF-16 appears in Windows APIs and JSON-encoded JavaScript strings; ASCII-7 in older text-only protocols. If the source is documented (HTTP ``Content-Type``, database column collation, file format spec), trust the documentation. If the source is mystery bytes, try UTF-8 first — it's the most common — and look for clues in the decoded output. Strip any prefix bytes that aren't part of the text (length headers, byte order marks — UTF-8 BOM is ``239, 187, 191`` and is usually safe to drop). When debugging, decode short prefixes first; if the first 16 bytes look right, the full payload almost certainly will too. Keep a copy of the original bytes when you decode — if a roundtrip (decode then re-encode) doesn't reproduce the input, the encoding assumption is wrong. For binary protocols where text fields are interleaved with non-text data, decode each text field separately rather than running the whole packet through a UTF-8 decoder.
The Tooloogle Byte Array to String Converter never uploads your bytes. The conversion uses the browser's native ``TextDecoder`` and ``Uint8Array`` APIs — both standard, no third-party libraries involved. Verify with DevTools Network tab that no requests fire as you type or paste. This makes the converter safe for proprietary protocol payloads, security-research data, NDA-protected customer payloads, regulated-industry content, and anything else you can't hand to an external service. Browser-only processing also means the tool works offline once the page has loaded.
Tooloogle's converter is focused on one thing: turning a list of decimal byte values back into the UTF-8 text those bytes encode. Auto-detected separator (comma or whitespace) means most pasted byte arrays just work without re-formatting. Live updates remove the click-to-convert step every other tool inserts. Native ``TextDecoder`` decoding correctly handles multi-byte UTF-8 sequences including emoji and CJK scripts. Browser-only processing keeps your bytes private and the tool fast. Bookmark the page next to your debugger and your packet-capture tool. If you need the reverse direction (text → bytes), use the Tooloogle String to Bytes Converter. For hex-encoded inputs, use the Hex to ASCII Converter. For binary-encoded text, use the Binary to Text Converter. For full base-N decoding of strings, see the Base64 Encoder/Decoder.
How to Use Byte Array to String Converter - Convert Bytes to Text Online
Enter or paste the content you want to process using the byte array to string converter - convert bytes to text online.
Adjust any available settings or options to customize the output.
View, copy, or download your processed results instantly.
Convert byte arrays to strings online. Decode space- or comma-separated bytes (decimal, hex, or binary) to UTF-8 text. Free browser-based byte-to-string converter.
Tool Use:
5.1k+Type:
Free ToolPrivacy:
Client SideEncode text or files to Base64 and decode Base64 strings back to text. Free, instant, browser-only — no upload, no logging.
Percent-encode strings for safe URL inclusion or decode percent-encoded URLs back to readable text — free and UTF-8 safe.
Convert any image (PNG, JPG, GIF, SVG, WebP) to a Base64 data URI for embedding in HTML, CSS, or JSON.
Decode Base64-encoded image strings back to viewable PNG / JPG / GIF / WebP images — free and instant.
Convert CSV files and pasted data to clean JSON instantly. Free online CSV to JSON converter with header detection, custom delimiters, and type parsing.