Hex to ASCII in Python, JavaScript, C and CLI

A production hex decoder has two jobs: reconstruct bytes and interpret those bytes with the intended character encoding. The first step turns 48656c6c6f into five byte values. The second reads those values as ASCII and returns Hello.

This guide focuses on implementations in Python, JavaScript, C, and shell. Use the browser hex decoder for a one-off value; use the code below when the conversion belongs in an application, test, or pipeline.

Define the Input Contract First

Hex uses two digits per byte. A strict converter should decide four things before it parses input:

1. Which separators are accepted, if any.
2. Whether a single leading 0x prefix is allowed.
3. Whether bytes above 7F should fail strict ASCII decoding.
4. Whether malformed input throws an error or returns a structured failure.

Do not remove every non-hex character and continue. That can turn corrupted input into different bytes. Normalize only the separators promised by the input format, then validate the complete result.

An odd number of hex digits is incomplete. Reject ABC unless the surrounding protocol defines how to interpret it. Padding it automatically is ambiguous: 0A BC and AB 0C are different byte sequences.

Python: bytes.fromhex and Strict ASCII

Python separates byte reconstruction from text decoding:

import re

HEX_RE = re.compile(r"^[0-9a-fA-F]*$")

def hex_to_ascii(value: str) -> str:
    compact = "".join(value.split())
    if compact.lower().startswith("0x"):
        compact = compact[2:]

    if not HEX_RE.fullmatch(compact):
        raise ValueError("input contains non-hex characters")
    if len(compact) % 2:
        raise ValueError("input ends with an incomplete hex byte")

    return bytes.fromhex(compact).decode("ascii")

assert hex_to_ascii("48 65 6c 6c 6f") == "Hello"

bytes.fromhex() accepts ASCII whitespace between byte values. The regular expression makes the accepted contract visible and prevents punctuation from disappearing unnoticed. .decode("ascii") then rejects any byte above 7F.

Decode as UTF-8 only when the data source says the bytes contain UTF-8:

text = bytes.fromhex("636166c3a9").decode("utf-8")
assert text == "café"

The hex to UTF-8 guide covers invalid sequences, replacement characters, and mojibake.

JavaScript in Node.js

Buffer.from(value, "hex") is convenient, but validate first because Node can stop at invalid input rather than throwing for every malformed string:

function normalizeHex(value) {
  let compact = value.replace(/\s+/g, "");
  if (/^0x/i.test(compact)) compact = compact.slice(2);

  if (!/^[0-9a-f]*$/i.test(compact)) {
    throw new TypeError("input contains non-hex characters");
  }
  if (compact.length % 2 !== 0) {
    throw new TypeError("input ends with an incomplete hex byte");
  }
  return compact;
}

function hexToAscii(value) {
  const bytes = Buffer.from(normalizeHex(value), "hex");
  if (bytes.some(byte => byte > 0x7f)) {
    throw new RangeError("input contains bytes outside ASCII");
  }
  return bytes.toString("ascii");
}

console.assert(hexToAscii("48656c6c6f") === "Hello");

For UTF-8, keep the validation and change the final interpretation to bytes.toString("utf8"). Decide whether replacement output is acceptable for the application.

JavaScript in the Browser

Browsers do not expose Node's Buffer by default. Parse each byte into a Uint8Array and reject non-ASCII values:

function hexToAsciiBrowser(value) {
  const compact = value.replace(/\s+/g, "").replace(/^0x/i, "");
  if (!/^[0-9a-f]*$/i.test(compact) || compact.length % 2 !== 0) {
    throw new TypeError("expected complete hexadecimal byte pairs");
  }

  const bytes = new Uint8Array(compact.length / 2);
  for (let i = 0; i < bytes.length; i += 1) {
    bytes[i] = Number.parseInt(compact.slice(i * 2, i * 2 + 2), 16);
    if (bytes[i] > 0x7f) {
      throw new RangeError("input contains bytes outside ASCII");
    }
  }

  return new TextDecoder("ascii", { fatal: true }).decode(bytes);
}

console.assert(hexToAsciiBrowser("48 69") === "Hi");

TextDecoder("ascii") follows the Encoding Standard's Windows-1252 label behavior in browsers, so the explicit byte > 0x7f check enforces the stricter 7-bit ASCII range.

C: Validate Before Writing Output

A C implementation should check input length and output capacity before it writes a terminator:

#include <stdbool.h>
#include <stddef.h>

static int hex_value(unsigned char c) {
    if (c >= '0' && c <= '9') return c - '0';
    if (c >= 'a' && c <= 'f') return c - 'a' + 10;
    if (c >= 'A' && c <= 'F') return c - 'A' + 10;
    return -1;
}

bool hex_to_ascii(
    const char *hex,
    size_t hex_length,
    char *output,
    size_t output_capacity
) {
    if (hex_length % 2 != 0 || output_capacity < hex_length / 2 + 1) {
        return false;
    }

    for (size_t i = 0; i < hex_length; i += 2) {
        int high = hex_value((unsigned char) hex[i]);
        int low = hex_value((unsigned char) hex[i + 1]);
        if (high < 0 || low < 0) return false;

        unsigned char byte = (unsigned char) ((high << 4) | low);
        if (byte > 0x7f) return false;
        output[i / 2] = (char) byte;
    }

    output[hex_length / 2] = '\0';
    return true;
}

This function accepts compact hex only. Normalize delimiters in a separate function so parsing rules stay visible. It also permits 00; callers that use C strings must remember that an embedded NUL ends the displayed string even though the byte was decoded correctly.

Command Line

xxd -r -p reconstructs bytes from plain hex:

printf '%s\n' '48656c6c6f' | xxd -r -p
# Hello

xxd reconstructs arbitrary bytes; it does not prove that the result is ASCII. A Python one-liner provides strict ASCII validation:

python3 -c 'print(bytes.fromhex("48656c6c6f").decode("ascii"))'

Use xxd -r rather than -r -p when the input is an xxd dump with offsets and an ASCII gutter. The hex dump guide compares xxd, hexdump, and POSIX od formats.

Common Failure Modes

Treating every byte as text

Hex can represent an image, executable, compressed stream, or encrypted payload. A successful hex parse proves only that the input contains byte values. Decode those bytes as text only when the source format calls for text.

Confusing ASCII with UTF-8

ASCII covers bytes 00-7F. UTF-8 uses the same values for that subset and multi-byte sequences for other Unicode code points. The bytes C3 A9 are valid UTF-8 for é, but they are outside ASCII.

Dropping leading zeroes

Each byte needs two hex digits. The byte 0A cannot be written as A in a byte stream without losing the boundary. Encoders should use two-digit formatting such as Python's f"{byte:02x}", JavaScript's padStart(2, "0"), or C's %02x.

Padding an odd nibble

Reject an incomplete pair and fix the producer. Padding is appropriate only when a specification defines which side receives the zero and confirms that the value is a number rather than a byte sequence.

Removing arbitrary punctuation

If an input contract allows spaces or colons, remove those separators and no others. Stripping every non-hex character can hide a truncated prefix, typo, or pasted ASCII gutter.

Hex Is a Representation, Not Security

Hex makes bytes readable with the characters 0-9 and A-F. It does not encrypt, compress, authenticate, or hide the original data. A secret written as hex remains a secret that must be protected.

Standard Base64 is denser than hex, but it is also a reversible byte representation. The ASCII to hex guide covers the opposite direction and compares output lengths.

FAQ

How do I convert hex to ASCII in Python?

Use bytes.fromhex(value).decode("ascii") after validating the accepted separators and checking for an even number of digits. Python raises ValueError for malformed hex and UnicodeDecodeError for bytes outside ASCII.

How do I convert hex to ASCII in JavaScript?

In Node.js, validate the complete string and use Buffer.from(value, "hex"), then reject bytes above 7F before calling toString("ascii"). In a browser, parse pairs into a Uint8Array and decode after the same range check.

Should an odd-length hex string be padded?

Usually no. An odd nibble indicates an incomplete byte. Reject it unless the data format explicitly defines numeric padding and says whether the zero belongs on the left or right.

Why does the decoded output contain replacement characters?

The bytes are not valid in the selected text encoding, or the sequence was truncated. Use strict decoding while debugging and verify the encoding from protocol metadata rather than guessing from a short sample.

Does byte order matter for ASCII text?

Endianness affects multi-byte numbers. ASCII maps each byte independently, so reversing byte order changes the character order rather than correcting the text. UTF-16 and UTF-32 have separate byte-order rules.

Is hexadecimal compressed data?

No. Hex expands each byte to two printable characters. It is a convenient representation for inspection and interchange, not a compression format.