JSON Schema to Protobuf Converter

Convert JSON Schema to proto3 message definitions — types, nested messages, enums, repeated fields

All processing happens in your browser. No data is sent to any server.

Options

Syntax:

Package:

JSON Schema Input

993 characters

Protobuf Output

syntax = "proto3";

package mypackage;

message User {
  enum Role {
    ADMIN = 0;
    USER = 1;
    GUEST = 2;
  }

  message Address {
    string street = 1;
    string city = 2;
    string zip = 3;
  }

  message OrdersItem {
    int32 order_id = 1;
    double total = 2;
    repeated string items = 3;
  }

  int32 id = 1;
  string name = 2;
  string email = 3;
  int32 age = 4;
  double score = 5;
  bool is_active = 6;
  Role role = 7;
  repeated string tags = 8;
  Address address = 9;
  repeated OrdersItem orders = 10;
}

3 messages + 1 enum generated · 531 characters

Messages: 3Enums: 1Syntax: proto3Package: mypackage

You have a JSON Schema defining your data model, and now you need Protocol Buffer definitions for gRPC services or efficient binary serialization. Manually translating JSON Schema types to proto3 message fields — mapping strings, numbers, booleans, nested objects, and arrays to their protobuf equivalents — is tedious and error-prone.

What Are Protocol Buffers?

Protocol Buffers (protobuf) is Google’s language-neutral, platform-neutral serialization format. Unlike JSON, protobuf uses a binary wire format that is smaller and faster to parse. Proto definitions (.proto files) describe message structures that are compiled into code for Go, Java, Python, C++, TypeScript, and other languages. Protobuf is the standard serialization format for gRPC.

How This Converter Works

Paste a valid JSON Schema and the tool generates proto3 message definitions:

Primitive type mapping: string → string, number → double, integer → int32, boolean → bool
Objects: type: "object" with properties becomes a message with numbered fields
Arrays: type: "array" with items becomes repeated fields
Nested objects: Inline object schemas become nested message definitions
Enums: enum arrays of strings become proto enum types
Optional fields: Properties not in required use the optional keyword (proto3)
$ref resolution: Internal references are resolved and generate separate named messages

Common Use Cases

REST to gRPC migration — Convert your existing JSON Schema API contracts to protobuf definitions when migrating from REST/JSON to gRPC.

Polyglot services — Generate proto definitions from your JSON Schema, then compile to Go, Java, Python, or TypeScript for consistent data structures across microservices.

Performance optimization — Replace JSON serialization with protobuf for internal service communication where payload size and parsing speed matter.

Schema evolution — Use protobuf’s built-in backward compatibility (field numbers) alongside your existing JSON Schema versioning strategy.

Proto3 Type Mapping Reference

JSON Schema	Proto3 Type
`string`	`string`
`number`	`double`
`integer`	`int32`
`boolean`	`bool`
`object`	`message`
`array`	`repeated`
`null`	`google.protobuf.NullValue`

Frequently Asked Questions

Q: Which protobuf syntax version is generated? A: The tool generates proto3 syntax, which is the current and recommended version. Proto3 has simpler semantics — all fields are optional by default, and the optional keyword explicitly marks presence tracking.

Q: How are nested JSON Schema objects handled? A: Each nested object becomes a nested message definition inside the parent message. Deeply nested structures produce correspondingly nested messages.

Q: What happens to JSON Schema $ref references? A: Internal $ref references are resolved and generate top-level message definitions. The referencing field uses the message name as its type.

Q: Are field numbers assigned automatically? A: Yes. Fields are numbered sequentially starting from 1 in declaration order. After generating, you should review and stabilize field numbers before using them in production, since changing numbers breaks backward compatibility.

Q: Is my schema sent to a server? A: No. All conversion runs in your browser using JavaScript. Your JSON Schema never leaves your device.

Related Tools

JSON Schema Validator

Validate JSON data against a JSON Schema (Draft 4 / 7 / 2020-12)

JSON to TypeScript

Convert JSON data to TypeScript interfaces and type aliases

JSON to Go

Convert JSON data to Go struct definitions with json tags

More Code Transforms

TypeScript to Zod JSON Schema to TypeScript GraphQL to TypeScript CSS to JS Objects SVG to JSX SVG to React Native View all →