What does the Hex Dump Diff tab show?

Paste a JSON document (or drop a file) and hit Compare bytes . The tool encodes it and renders two classic hex dumps: JSON text bytes — the pretty-printed document as UTF-8, every quote, brace, comma, and space visible. MessagePack bytes — the binary encoding, annotated with the root type read from the first byte, e.g. fixmap · 2 entries . Both columns share a byte offset ruler, so you can trace exactly how a single value is represented in each format. A summary row reports both sizes plus the percentage saved.

What extension types can the schema hint decode?

The built-in hints are timestamp / date / time , uuid , hex , utf8 / text / string , int8/16/32/64 , uint8/16/32/64 , float32/64 , and base64 . Unregistered ext values are shown as {"$extType":…,"$extData":"hex"} so nothing is silently dropped.

Is the MessagePack tool free and private?

Yes, on both counts. Encoding, decoding, schema hints, and hex dumps all run client-side with @msgpack/msgpack — your data never leaves your device, is never transmitted, and is never cached on a server. No account or API key required.

MessagePack (MsgPack) Encode & Decode Online

Like JSON but faster and 20-30% smaller — convert between JSON and compact MessagePack, or diff the raw bytes side by side.

Binary output

Result

JSON input

What is MessagePack Encoder / Decoder?

MessagePack is an efficient binary serialization format — like JSON but faster and more compact. It turns JSON-compatible data into compact binary that is typically 20-30% smaller than the text equivalent, making it the format of choice for high-performance APIs, real-time services, and caching layers where payload size and parse speed matter. Encode JSON to MessagePack, decode a hex dump back to readable JSON, or compare the two byte streams side by side in the Hex Dump Diff tab — all locally in your browser.

Convert — encode JSON to MessagePack (hex or base64) or decode it back.

Typed decode — decode int64/uint64 as BigInt and map ext types (timestamp, uuid, hex, …) with a schema hint.

Hex Dump Diff — compare the JSON text bytes against the MessagePack bytes byte-for-byte.

100% client-side — everything runs locally with @msgpack/msgpack.

Zero-Server Tool Data Guarantee

All encoding and decoding happens locally in your browser. Your data is never sent to any server.

How to Use

Choose Your Mode

Select 'Encode' to turn your JSON data into MessagePack binary format, or 'Decode' to convert MessagePack bytes back to JSON. Drop a file instead of pasting — decode mode reads the raw bytes.

Set Encoding Type

Pick either 'Hex' or 'Base64' as the text representation for your binary MessagePack data.

Add a Schema Hint (decode)

Open 'Schema hint · typed decode' to decode 64-bit integers as BigInt and map ext type numbers to readable types like timestamp or uuid.

Diff the Bytes

Open the Hex Dump Diff tab to see your JSON and its MessagePack encoding side by side as hex dumps with offset rulers and top-level type annotations.

Process and Copy

Your results are generated instantly. Use the copy button to save the encoded binary string or the decoded JSON object.

Common Use Cases

Real-Time APIs

Serialize WebSocket messages with MessagePack for faster parsing and smaller payloads than JSON.

Cache Serialization

Store complex objects in Redis or Memcached using MessagePack for compact, fast serialization.

Inter-Service Communication

Replace JSON with MessagePack in microservice communication to reduce network overhead and parsing time.

Round-Trip Testing

Verify encode → decode round-trips and inspect the binary output side by side with JSON during schema migrations.

Implementation Examples

JavaScriptMessagePack (@msgpack/msgpack)

import { encode, decode } from '@msgpack/msgpack';

// Encode JSON to MessagePack
const encoded = encode({ name: "Alice", scores: [95, 87, 92] });
console.log(encoded); // Uint8Array of binary bytes

// Decode MessagePack to JSON
const decoded = decode(encoded);
console.log(decoded); // { name: "Alice", scores: [95, 87, 92] }

// Size comparison
const jsonStr = JSON.stringify({ name: "Alice", scores: [95, 87, 92] });
console.log(`JSON: ${jsonStr.length} bytes, MsgPack: ${encoded.length} bytes`);

MessagePack vs JSON vs Protobuf

Feature	MessagePack	JSON	Protobuf
Format	Binary	Text	Binary
Schema?	No	No	Yes (required)
Size vs JSON	20-30% smaller	Baseline	60-80% smaller
Parse speed	Very fast	Slow	Very fast
Human readable?	No	Yes	No
Extensibility	Extension types	None	Schema evolution
Best for	Caching, real-time	APIs, config	Microservices, gRPC

Production Best Practices & Security

Use for performance-critical APIs — MessagePack is significantly faster to parse than JSON for high-traffic endpoints. Why:It uses a binary format that avoids the expensive string parsing and character-by-character scanning required by JSON.

Use for cache storage — compact binary format makes it ideal for Redis, Memcached, and local cache. Why:Smaller serialized objects save memory in your cache layer and reduce the time spent on I/O when reading and writing.

Be aware of type mappings — MessagePack maps JavaScript numbers differently (int vs float); test edge cases. Why:Unlike JSON which treats all numbers as doubles, MessagePack uses specific integer and float types. This can sometimes lead to unexpected precision issues or type errors in strictly-typed languages.

Use hex for debugging — binary MessagePack is unreadable raw; the hex dump helps with analysis. Why:Hex lets you see the exact bytes being sent, which is crucial for identifying where a serialization error might be occurring.

Handle extension types — MessagePack supports custom types via the ext mechanism; define a consistent scheme. Why:Extensions let you serialize complex types like Dates or custom classes, but they require both the sender and receiver to share the same extension logic. Use the schema hint to decode them as readable types.

Don't use for human-editable data — if humans need to read or edit the data, stick with JSON or YAML. Why:MessagePack is a binary format. Editing it manually with a text editor will likely corrupt the file and make it unreadable by your application.

Frequently Asked Questions

MessagePack is a binary serialization format that represents JSON-compatible data structures (objects, arrays, strings, numbers, booleans, and null) in a compact binary form.

It uses single-byte prefixes for common values — a small positive integer takes just 1 byte instead of up to 15 characters in JSON. This makes MessagePack payloads typically 20-30% smaller than their JSON equivalents and faster to parse because there is no text scanning involved.

You will find it in high-performance APIs, real-time systems, and internal data storage.

It bundles MessagePack round-trip work into one page: Convert (encode JSON to MessagePack hex/base64 or decode it back), typed decode (BigInt precision plus a schema hint that maps extension type numbers to readable types like timestamp or uuid), and a Hex Dump Diff tab that renders the JSON text bytes and the MessagePack bytes side by side with offset rulers and top-level type annotations. Everything runs in your browser.

For typical structured data, MessagePack is 20-30% smaller than JSON — and the savings show up byte-for-byte in the Hex Dump Diff tab. In the page example, a 36-byte JSON document becomes 23 bytes of MessagePack (36% smaller).

The savings come from no whitespace or structural punctuation (no braces, quotes, or commas), single-byte type prefixes (0x82 = 2-entry map, 0x93 = 3-item array), and compact integers that fit in one byte instead of several characters. The exact ratio depends on your data: lots of small numbers and short strings compress well; long strings and binary payloads compress less.

It depends on your use case. MessagePack wins on payload size (typically 20-30% smaller) and parse speed (2-5x faster because there is no text parsing overhead). This makes it excellent for high-throughput APIs, WebSocket messages, and cache storage where every byte and microsecond counts.

JSON wins on universality — every language and tool can handle JSON without additional libraries, and it is human-readable for debugging.

Many systems use both: JSON for external APIs and MessagePack for internal service-to-service communication.

Both are schemaless binary formats that pack JSON-like data far smaller than plain text, but they optimize for different things.

MessagePack favors raw simplicity and speed — a few short type prefixes keep parsing minimal, which is why it is a common choice for high-throughput APIs, WebSocket payloads, and cache layers.

CBOR (RFC 8949) favors extensibility and standards compliance — its tag system represents dates, big integers, byte strings, and custom semantic types out of the box, and it is the encoding behind WebAuthn, COSE, and IoT protocols like CoAP.

If your data is plain JSON-shaped objects and you want the fastest possible round trip, MessagePack is hard to beat. If you need standards-based tags or richer built-in types, try our CBOR Encode & Decode tool to compare the two side by side.

Paste a JSON document (or drop a file) and hit Compare bytes. The tool encodes it and renders two classic hex dumps:

JSON text bytes — the pretty-printed document as UTF-8, every quote, brace, comma, and space visible.
MessagePack bytes — the binary encoding, annotated with the root type read from the first byte, e.g. fixmap · 2 entries.

Both columns share a byte offset ruler, so you can trace exactly how a single value is represented in each format. A summary row reports both sizes plus the percentage saved.

MessagePack ext values are raw bytes tagged with a type number — the decoder cannot know what they mean without a hint. In decode mode, open Schema hint · typed decode and map type numbers to JS types, e.g. {"-1":"timestamp","7":"uuid"}. The tool then decodes those bytes as ISO date strings or formatted UUIDs instead of raw hex. Tick Decode 64-bit integers as BigInt to preserve full precision on int64/uint64 values.

Paste hex-encoded MessagePack data into the input field and select the Decode mode — or drop a .bin/.msgpack file, which is read as raw bytes. The tool parses the binary format and displays the result as readable JSON, handling all MessagePack types including integers, floats, strings, binary, arrays, maps, timestamps, and extension types.

If your data comes from a high-performance API or cache, the tool structures the output for easy inspection. Click the copy button to copy the decoded JSON.

Yes. The MessagePack tool uses the @msgpack/msgpack library entirely in your browser. Once the page loads, all encoding and decoding operations happen locally — you can disconnect from the internet and it will work perfectly.

This also means your data never leaves your device. That is especially valuable when working with sensitive serialized payloads like session data, configuration blobs, or proprietary message formats.