Input

Output

What is MessagePack to JSON?

Your gRPC sidecar logs the request body as a long hex string and you need to actually read what is in it. Or Redis returned a value that the previous service stored as msgpack and your terminal is showing \x82\xa7orderId\xa8ORD-7421. MessagePack is a compact binary format — great on the wire, unreadable in a log line. This page takes the hex or base64 dump and gives you the JSON it represents.

Decoding follows the official MessagePack wire-format spec via the @msgpack/msgpack JavaScript library. Maps become objects, arrays become arrays, and numbers become JSON numbers, pretty-printed as RFC 8259 JSON. 64-bit integers stay exact: a uint64 like 8901240544102066246 comes out with every digit, not rounded to a double. Hex with 0x prefixes, spaces or commas parses fine, and so does Base64 or Base64URL (RFC 4648), detected automatically.

No upload, no backend, no logging. The decode runs in your browser as a plain Uint8Array — close the tab and the bytes are gone.

How to Use MessagePack to JSON

Paste, read, copy. There is no Convert button — the right pane updates as you type, with a 300 ms debounce so it does not thrash on every keystroke.

Paste the Hex or Base64

Drop the MessagePack bytes into the left editor. Raw hex (82a7...), spaced hex (82 a7 6f), 0x-prefixed bytes, Base64, Base64URL, and escaped byte strings like Python's b'\x82\xa7orderId...' or redis-cli's "\x82\xa7orderId..." all work. Hit Sample to load an order payload that decodes to a real object.

82 a7 6f 72 64 65 72 49 64 a8 4f 52 44 2d 37 34 32 31 a5 74 6f 74 61 6c cb 40 56 60 00 00 00 00 00

Paste that and you get {"orderId": "ORD-7421", "total": 89.5}. 82 is a map with two entries, a7 is a 7-byte string ("orderId"), and cb is a float64.

Read the JSON on the Right

The right pane re-decodes on every change. If the bytes are valid MessagePack you see the object. If they are truncated, have extra bytes at the end, or are actually a different format (CBOR, BSON, protobuf), the pane says what went wrong in plain words, for example that the bytes run out before the value is complete.

Copy What You Need

Hit the Copy button on the output side to grab the JSON, or Download to save it as decoded.json. Drop it into a unit test fixture, paste it into a bug ticket, or feed it into the JSON Formatter if you want different indentation. To go the other direction (object to msgpack), use JSON to MessagePack.

When You'd Actually Use This

Read a gRPC or Sidecar Log Body

A service-mesh sidecar dumps request bodies as hex. The body is msgpack because that is what the upstream service serializes with. Paste the hex, see the object, find out the call had orderId: "ORD-7421" and total: 89.50 instead of guessing.

Inspect a Redis Value

You stored an object in Redis with a msgpack codec to save space. Now you want to know what is in session:42 without writing a script. Run GET, copy the value (most clients show it as hex or base64), paste it here.

Compare a Cached Blob With the Live API

A service caches API responses as msgpack to save memory, and a customer swears the page shows stale data. Pull the cached bytes, decode them here, and diff the result against the live JSON response. If you want to know more about why teams pick MessagePack for this, the size savings come mostly from dropping quotes and using one-byte type markers.

Sanity-Check What a Client Is Sending

You wrote a mobile client that encodes the request body with msgpack to save bandwidth. You hit a regression. Capture the actual bytes (Charles, mitmproxy, network tab), paste, and confirm the field names and values match the schema your server expects. Customer name Ava Chen, items SKU-101 × 2 — yes or no.

Common Questions

Are my bytes uploaded anywhere?

No. The decode is pure JavaScript in your browser — the @msgpack/msgpack library reads your input as a Uint8Array, walks the wire format, and renders the resulting object as JSON. There is no fetch, no analytics on the input, nothing leaves the tab. Treat it the same as any local CLI tool.

Hex or base64 — does it matter which I paste?

Either works. The tool tries hex first (hex with 0x prefixes, spaces or commas is the most common log shape) and falls back to Base64 if the input isn't hex. Base64URL with - and _ works too. Escaped byte strings decode as well: a Python b'\x82\xa7orderId...' literal or a redis-cli style "\x82\xa7orderId..." string, where \xNN escapes are mixed with plain text, is read byte by byte.

Why does my output show timestamps as something weird?

MessagePack has a built-in timestamp extension type that the library decodes to a JS Date. When stringified into JSON that becomes an ISO 8601 string. If you see a string like "2026-05-05T12:34:56.000Z" in the output, that is a real timestamp the encoder embedded — not a bug.

What if the input is partially valid?

The decoder reads the wire format byte by byte. If a length prefix says "next is a 16-byte string" and only 8 bytes are left, decoding stops and the right pane tells you the input ends too early. If one complete value decodes but bytes are left over, it tells you at which byte the value ended. That's normally enough to spot a truncated paste or a stray byte.

Can it handle binary blobs (the bin family)?

Yes. bin 8/bin 16/bin 32 values come back as raw bytes. JSON has no bytes type, so they show up as an array of numbers, e.g. {"b":[1,2,3]}. If you need Base64 for those fields instead, you'll have to convert that array yourself; this page doesn't do it.

How does this compare to protobuf or CBOR?

MessagePack is schemaless (the keys live in the bytes), CBOR is similar but has more types and a different encoding, and protobuf needs a .proto schema to decode at all. If your bytes are protobuf, this tool will fail. Look at the Protobuf to JSON page for working with .proto schemas. If they're CBOR, the wire format is close but not the same, so you'd need a CBOR-specific decoder.

Other MessagePack Tools

MessagePack tools that pair well with this one — go the other direction, validate, or just look at the bytes: