Skip to content

Protobuf Decoder

Binary input

.proto schema (optional)

Parsed 1 message(s): Person

Decoded (28 bytes)

#1namestringlength-delimited
string: Alice
bytes (hex): 41 6c 69 63 65
length: 5
#2idint32varint
uint64: 42
int64: 42
sint64 (zigzag): 21
bool: 42 (not 0/1)
#3emailstringlength-delimited
string: [email protected]
bytes (hex): 61 6c 69 63 65 40 65 78 61 6d 70 6c 65 2e 63 6f 6d
length: 17

What This Tool Does

Paste a protobuf payload as hex or base64 and the decoder walks the wire format in your browser, showing each field's tag number, wire type, and the plausible value interpretations. Add a .proto schema to label fields by name. Nothing leaves your device. Because protobuf drops field names on the wire, a schema-less decode shows numeric tags rather than names — that is expected, not an error.

Last updated:

This tool is provided as-is for convenience. Output should be verified before use in any production or critical context.

Agent Invocation

Best Path For Builders

Browser workflow

Runs instantly in the browser with private local processing and copy/export-ready output.

Browser Workflow

This tool is optimized for instant in-browser execution with local data handling. Run it here and copy/export the output directly.

/protobuf-decoder/

For automation planning, fetch the canonical contract at /api/tool/protobuf-decoder.json.

How to Use Protobuf Decoder

  1. 1

    Paste your binary payload

    Drop the protobuf bytes into the input as hex or base64. The format toggle controls how the payload is parsed before decoding starts.

  2. 2

    Optionally provide a .proto schema

    Paste your message definitions to get named fields and typed values. Without a schema the decoder still infers wire type, varint width, and nested message candidates.

  3. 3

    Pick the root message

    When multiple messages parse from the .proto, choose which one represents the top-level payload. The selector shows every parsed message name.

  4. 4

    Switch between tree and JSON

    The tree view shows tag, wire type, and every plausible interpretation per field. The JSON view collapses everything into a structured object you can paste into a bug report.

Frequently Asked Questions

What is Protobuf Decoder?
Protobuf Decoder turns binary protobuf payloads into structured output. Paste hex or base64 bytes, optionally pair them with a .proto schema, and inspect each tag, wire type, and nested message.
Can it decode a payload without a schema?
Yes. The schema-less path infers wire types, decodes varints, fixed32, and fixed64, and recursively probes length-delimited fields as candidate nested messages or printable UTF-8 strings.
Which Protobuf wire types are supported?
Varint, length-delimited, fixed32, and fixed64 are decoded. Group start and group end markers are reported as raw wire types since proto2 groups are deprecated and rare in modern payloads.
Does it send my data to a server?
No. The hex or base64 input, the .proto schema, and the decoded output stay inside your browser tab. Decoding runs synchronously on the same JavaScript thread that renders the page.
Is Protobuf Decoder free?
Yes. The tool runs entirely in your browser with no signup and no usage cap beyond what your device and tab can handle.

How do I decode a protobuf binary payload without the .proto file?

Protobuf encodes each field as a tag (the field number plus a wire type) followed by its value, and it never stores field names or declared types in the bytes. That means you can always decode the structure — tag numbers, wire types, and raw values — without a schema. What you cannot recover without the .proto is the field names and which of several numeric interpretations was intended, so the decoder shows every candidate.

Step by step

  1. Choose hex or base64 and paste the payload — it is decoded in the page, never uploaded.
  2. Read the tree: each field shows its tag number, wire type, and the value under every interpretation that wire type allows.
  3. Optionally paste a .proto schema and pick the root message to label fields by name and type.
  4. Length-delimited fields that parse as a valid sub-message are decoded recursively as nested messages.
  5. Switch to the JSON view to copy a structured representation of the decode.

Protobuf wire types this decoder reads

Wire type # Interpretations shown
varint 0 uint64, int64, sint64 (zigzag), bool
fixed64 1 fixed64 (uint64), sfixed64 (int64), double
length-delimited 2 string, bytes (hex), nested message, length
fixed32 5 fixed32 (uint32), sfixed32 (int32), float

Wire types as this decoder implements them. Group wire types (start-group 3 and end-group 4), the deprecated proto2 grouping encoding, are not decoded and raise an "unknown wire type" error.

What do the multiple interpretations mean?

A single varint on the wire could be an unsigned integer, a two's-complement signed integer, a zigzag-encoded signed integer, or a boolean — the bytes are identical, only the declared field type differs. The decoder lists all of them so you can match the value to what your schema expects. Supply the .proto and it resolves each field to one named type instead.

Can it decode nested messages?

Yes. A length-delimited field can hold a string, raw bytes, or another message. The decoder tries to re-parse those bytes as a sub-message; when they parse cleanly it shows the nested fields, otherwise it falls back to string or hex. This heuristic is why a byte blob occasionally renders as a spurious nested message — a schema removes the ambiguity.

Is my payload uploaded anywhere?

No. Hex and base64 are decoded and interpreted entirely in the page. Protobuf payloads captured from gRPC traffic often carry auth tokens, identifiers, or personal data, so decoding them locally rather than pasting them into a server-side tool is the safe choice.