Paste a .proto schema here to view itPaste .proto
Paste a valid .proto schema to see the structure

What is the Protobuf Viewer?

A raw .proto file is fine when you wrote it yourself. When somebody hands you a 600-line schema with twelve nested messages and three oneofs, scrolling around in a text editor stops being fun. The Protobuf Viewer parses the schema in your browser and lays each message out as a table — field name, type, number, and rule (singular, repeated, optional, map) all in plain sight.

It's built for the moment you just want to SEE the schema. Not generate code, not validate it, not convert it to JSON — see it. Drop in the .proto from a gRPC service, a vendor SDK, or a colleague's pull request, and the structure shows up in a single glance: how many messages, what fields each one has, which numbers are reserved, where the enums live.

Everything runs in your browser — no upload, no protoc install, no account. Paste, look, close the tab.

How to View a .proto Schema Here

Three steps from paste to readable schema. The buttons match what you're reading here.

1

Paste or Load a Sample

Copy a .proto file from your repo, your gRPC server, or a public vendor schema, and paste it into the editor on the left. If you want to see the viewer in action first, click Sample to load a small e-commerce schema with messages, an enum, and a few nested types.

syntax = "proto3";

message Order {
  string id = 1;
  Customer customer = 2;
  repeated LineItem items = 3;
  OrderStatus status = 4;
}

If the schema has syntax errors, you'll see a message under the editor pointing at the line where the parser gave up.

2

Browse the Messages

The right side re-renders instantly whenever your input changes. Each top-level message shows up as its own row with a fields column — expand it and you see name, type, number, and rule for every declared field. Nested messages and enums get their own rows, so you can follow a chain like Order → Customer → Address visually. The schema reading follows the rules in the proto3 language spec.

3

Filter and Reorient

Every column has a filter box. Type string in the type column to see only string fields, repeated in the rule column to spot all the lists, OrderStatus in the type column to find every reference to a particular enum. Use Main or Nested to flip orientation when a message has more fields than messages — sometimes it's easier to read fields as rows and messages as columns.

4

Go Full Screen for Big Schemas

For schemas with 20+ messages — the kind that come out of a busy gRPC service or a vendor SDK — hit Full Screen. The table expands to the full viewport so you can scroll through dozens of messages without the editor pane in the way.

5

Export When You're Done

Need to walk a non-developer through the schema, or paste it into a design doc? Hit Excel to download the rendered table as .xls, openable in Excel, Google Sheets, or LibreOffice Calc. Parsing happens client-side using a small handwritten .proto parser — nothing is uploaded.

When the Viewer Pays Off

Reading a Vendor SDK Schema

A vendor ships a 1,200-line .proto for their REST-replacement API. You need to know whether CreatePaymentRequest takes a customer ID or a token. Paste the file, filter the messages column for Payment, and you have the field list in two seconds — way faster than scrolling through a single editor view.

Code Review for a New Service

A teammate opens a PR adding a new gRPC service. Paste their .proto here and you can spot at a glance: which fields are repeated when they probably shouldn't be, which numbers got reused after a delete, which enum is missing the zero value. Catches schema-design issues that a code editor diff hides.

Onboarding to a Codebase

New on a team that uses protobuf heavily? Drop the main .proto in here and walk through the messages without having to set up buf or run protoc. You get the data model in one screen instead of clicking around 30 generated language bindings.

Showing the API to a PM

Your PM wants to know what the new checkout RPC accepts. "Here's the .proto" lands flat. Paste it here, share your screen on the table view, and they see CheckoutRequest with its fields laid out in a table they can actually read. No explanation of = 4; needed.

FAQ

What's the difference between this and a Protobuf Validator?

A validator focuses on whether your schema is correct — reserved-number conflicts, missing zero values in proto3 enums, that kind of thing. A viewer focuses on browsability: it shows you what's in the schema so you can read it. There's overlap (the viewer flags syntax errors), but if you want a lint report, use the Protobuf Validator; if you want to read the schema, this is the better tool.

Does my .proto file leave my browser?

No. Parsing and rendering happen locally in JavaScript. The schema string never gets uploaded to a server. If you're looking at something proprietary or pre-release, that's the right answer — paste it, browse it, close the tab.

Does it support proto2 or only proto3?

Both. The parser handles syntax = "proto2" and syntax = "proto3", including required, optional, repeated, map<K,V>, oneof, nested messages, and nested enums. The proto2 spec covers the legacy syntax for the older parts of a schema you might inherit.

What about service definitions and RPC methods?

The parser reads service blocks but doesn't render RPC methods in the table view — the focus is the data shape, not the surface area. If you want to see RPC details, look at the raw schema in the editor pane on the left, or run buf lint against the file.

Can it handle imports across multiple .proto files?

Single-file only. import "other.proto"; directives are parsed but the contents of the imported file aren't fetched (your browser can't reach into your filesystem). If you need a multi-file schema browser, generate a single bundle with protoc --include_imports --descriptor_set_out first, or use a hosted tool like Buf Schema Registry.

How big a schema is comfortable?

Schemas up to a few thousand lines render fast. The Google APIs google.api set, the gRPC reflection schema, things at that scale are fine. Past 10,000 lines you'll feel the table getting heavy — in practice that's rare for a single .proto file because most real schemas split across many files long before that.

Related Protobuf Tools

Viewing is one slice of what you might want to do with a .proto file. If you need something more specific, try these: