BYTETOOLS

Protobuf Decoder

Decode raw Protocol Buffers wire-format bytes without a .proto file. Paste hex or Base64 and read every field number, wire type and value.

Or drop a binary file
Drop a .bin / .pb fileRead locally, never uploaded (max 4 MB)
33
Bytes parsed
7
Fields found

Field tree

  • Field 1length-delimitedoffset 0 · 11 bytes
    string
    ByteTools
    bytes
    9 bytes

    raw: 42 79 74 65 54 6f 6f 6c 73

  • Field 2varintoffset 11 · 2 bytes
    uint32 / uint64 / bool
    42
    int32 / int64 (two's complement)
    42
    sint32 / sint64 (zigzag)
    21
  • Field 3length-delimitedoffset 13 · 13 bytes
    Nested message — 2 fields
    • Field 1varintoffset 15 · 3 bytes
      uint32 / uint64 / bool
      150
      int32 / int64 (two's complement)
      150
      sint32 / sint64 (zigzag)
      75
    • Field 2length-delimitedoffset 18 · 8 bytes
      string
      nested
      bytes
      6 bytes

      raw: 6e 65 73 74 65 64

  • Field 5fixed32 (32-bit)offset 26 · 5 bytes
    fixed32
    1078523331
    sfixed32
    1078523331
    float
    3.140000104904175

    raw: c3 f5 48 40

  • Field 6varintoffset 31 · 2 bytes
    uint32 / uint64 / bool
    1
    int32 / int64 (two's complement)
    1
    sint32 / sint64 (zigzag)
    -1
    bool
    true

JSON (field numbers as keys)

{
  "1": "ByteTools",
  "2": "42",
  "3": {
    "1": "150",
    "2": "nested"
  },
  "5": "1078523331",
  "6": "1"
}

Without a .proto file the wire format cannot tell an int32 from a bool, or a nested message from a packed repeated field, so every plausible reading is shown side by side.

What is the Protobuf Decoder?

The ByteTools Protobuf Decoder takes raw Protocol Buffers bytes and shows you what is inside them, even when you do not have the .

  • Works with no .proto schema — pure wire-format parsing
  • Hex, Base64 or a dropped binary file as input
  • Nested messages detected and re-parsed recursively
  • Varints shown as uint64, signed int64 and zigzag sint64
  • Byte offsets and field sizes for every entry
  • 100% client-side — payloads never leave your browser

How to use the Protobuf Decoder

  1. 1

    Choose whether your data is hex or Base64, then paste it into the box — or drop a binary .bin or .pb file to load its bytes.

  2. 2

    Read the field tree: each entry shows the field number, its wire type and every value interpretation the wire format allows.

  3. 3

    Expand a nested message to walk into sub-messages, and tick the offsets box to see where each field starts and how long it is.

  4. 4

    Copy or download the JSON view, which keys every value by its field number so you can match it against your .proto file.

About the Protobuf Decoder

The ByteTools Protobuf Decoder takes raw Protocol Buffers bytes and shows you what is inside them, even when you do not have the .proto schema. It walks the wire format one field at a time, reading each key varint to recover the field number and wire type, then decoding varints, 64-bit and 32-bit fixed values, and length-delimited payloads.

Because the wire format does not record type names, a length-delimited field could be a string, a nested message or a packed repeated list. The decoder tries to re-parse each payload as a nested message and falls back to UTF-8 text or hex, and it shows every plausible reading of a varint side by side so you can pick the one your schema expects.

Everything runs 100% locally in your browser. The bytes you paste, and any file you drop, are never uploaded, logged or stored, so it is safe to inspect production payloads and captured gRPC traffic. That makes the tool a practical first step when an API returns something unexpected and you need to see the raw structure before going hunting for the schema that produced it.

Frequently asked questions

Can you decode protobuf without the .proto file?

Yes, up to a point. The wire format records each field's number and one of four wire types, so the structure and the raw values always come through. What it cannot tell you is the field names or whether a number was meant to be an int32, a bool or an enum, which is why this tool shows every valid interpretation at once.

Why does one field show three different numbers?

A varint on the wire is just a sequence of bits. Depending on the schema it may be a plain unsigned integer, a two's-complement signed integer, or a zigzag-encoded sint32 or sint64. All three readings come from the same bytes, so the decoder prints them together and lets you choose.

What does length-delimited mean in protobuf?

Wire type 2 covers strings, byte arrays, nested messages and packed repeated fields — anything with an explicit length prefix. The decoder reads that length, then tries to parse the payload as a nested message; if that fails it shows the bytes as UTF-8 text or hex instead.

Why did my paste fail to decode?

Protobuf has no magic number or header, so any wrong starting offset produces nonsense almost immediately. Common causes are including an HTTP or gRPC frame header, pasting only part of the message, or the data not being protobuf at all. Try trimming leading framing bytes and decoding again.

Is my protobuf payload uploaded anywhere?

No. Parsing happens entirely in your browser with JavaScript, and no network request is made. That makes it safe for payloads containing customer data, tokens or anything else you would not paste into a server-side tool.

Related tools