CSV to Protocol Buffers Converter — Free Online .proto Schema Generator

What Are Protocol Buffers?

Protocol Buffers (Protobuf) is a language-neutral, platform-neutral serialization format developed by Google. It defines structured data schemas in .proto files, then generates code for 15+ languages.

syntax = "proto3";

package example;

message Person {

 string name  = 1;

 int32  age   = 2;

 string email = 3;

}

Why Protocol Buffers?

Who Uses Protocol Buffers?

Proto2 vs Proto3

.proto File Structure

syntax = "proto3";           // Required: proto version

package myapp.v1;            // Namespace

option java_package = "com.example.myapp.v1";

option go_package = "github.com/example/myapp/v1";

message User {               // Message definition

 int32  id       = 1;       // Field: type, name, field number

 string name     = 2;

 string email    = 3;

 bool   active   = 4;

 double balance  = 5;

}

enum Status {                // Enum definition

 UNKNOWN   = 0;

 ACTIVE    = 1;

 SUSPENDED = 2;

}

Protobuf Scalar Types

CSV-to-Protobuf Type Inference

Since CSV is all text, the tool infers protobuf types from values:

Field Number Assignment

Field numbers are assigned sequentially starting from 1, matching column order in the CSV.

Why Convert CSV to Protobuf Schema?

Core Features

1. Online Table Editor

After loading CSV data, an interactive spreadsheet grid lets you edit before converting:

2. Automatic Type Inference

The tool analyzes CSV cell values and infers the correct protobuf scalar type:

• Numeric-only columns → int32 or double

• Boolean columns → bool

• Text columns → string

3. Privacy by Design

All processing runs entirely in your browser. No CSV data is uploaded to any server.

How to Use

Step 1: Load CSV Data

Choose one of two input methods:

• Upload a file: Click "Choose File" and select a .csv file.

• Paste data: Click "Enter Data" to switch to the code editor. Paste your CSV.

Step 2: Edit in Table Editor (Optional)

Use the toolbar to clean your data before converting. Remove empty rows, deduplicate, fix casing.

Step 3: Enable "First Row as Header"

Toggle this ON to use the first CSV row as field names in the generated .proto message.

Step 4: Convert

Click Convert. The .proto schema appears in the "Output Data" panel.

Step 5: Copy or Download

• Click Copy to Clipboard to paste into your .proto file.

• Premium users can click Download File to save.

Complete Example — User Data

Input CSV:

id,name,email,age,active,balance

1,Alice,[email protected],30,true,1250.50

2,Bob,[email protected],25,false,0.00

3,Charlie,[email protected],35,true,9800.75

Output .proto:

syntax = "proto3";

message Record {

 int32  id      = 1;

 string name    = 2;

 string email   = 3;

 int32  age     = 4;

 bool   active  = 5;

 double balance = 6;

}

Example — Sensor Readings

Input CSV:

sensor_id,timestamp,temperature,humidity,location

SENS-01,1714953600,22.5,45.2,Warehouse-A

SENS-02,1714953600,18.3,62.1,Warehouse-B

SENS-03,1714953600,25.0,38.7,Warehouse-A

Output .proto:

syntax = "proto3";

message Record {

 string sensor_id    = 1;

 int64  timestamp    = 2;

 double temperature  = 3;

 double humidity     = 4;

 string location     = 5;

}

Example — Product Catalog

Input CSV:

sku,name,category,price,in_stock,weight_kg

SKU-1001,Wireless Mouse,Electronics,29.99,true,0.08

SKU-1002,Mechanical Keyboard,Electronics,149.99,true,0.85

SKU-1003,USB-C Cable,Accessories,12.99,true,0.05

SKU-1004,Monitor Stand,Furniture,79.99,false,3.20

Output .proto:

syntax = "proto3";

message Record {

 string sku         = 1;

 string name        = 2;

 string category    = 3;

 double price       = 4;

 bool   in_stock    = 5;

 double weight_kg   = 6;

}

Using the Generated .proto File

Python

pip install grpcio-tools

python -m grpc_tools.protoc --python_out=. --proto_path=. data.proto

import data_pb2

record = data_pb2.Record(

   id=1,

   name="Alice",

   email="[email protected]",

   age=30,

   active=True,

   balance=1250.50

)

serialized = record.SerializeToString()

print(f"Serialized: {len(serialized)} bytes")

new_record = data_pb2.Record()

new_record.ParseFromString(serialized)

print(new_record.name)

Go

go install google.golang.org/protobuf/cmd/protoc-gen-go@latest

protoc --go_out=. data.proto

package main

import (

   "fmt"

   "google.golang.org/protobuf/proto"

   pb "yourmodule/data"

)

func main() {

   record := &pb.Record{

       Id:      1,

       Name:    "Alice",

       Email:   "[email protected]",

       Age:     30,

       Active:  true,

       Balance: 1250.50,

   }

   data, _ := proto.Marshal(record)

   fmt.Printf("Serialized: %d bytes\n", len(data)

   )

}

Java

<dependency>

   <groupId>com.google.protobuf</groupId>

   <artifactId>protobuf-java</artifactId>

   <version>4.29.3</version>

</dependency>

protoc --java_out=src/main/java data.proto

Record record = Record.newBuilder()

   .setId(1).setName("Alice")

   .setEmail("[email protected]")

   .setAge(30)

   .setActive(true)

   .setBalance(1250.50)

   .build();

byte[] data = record.toByteArray();

System.out.println("Serialized: " + data.length + " bytes");

Node.js / TypeScript

npm install google-protobuf

npx pbjs -t static-module -w commonjs -o data.js data.proto

npx pbts -o data.d.ts data.js

const messages = require("./data.js");

const record = messages.Record.create({

   id: 1,

   name: "Alice",

   email: "[email protected]",

   age: 30,

   active: true,

   balance: 1250.50,

});

const buffer = messages.Record.encode(record).finish();

console.log(`Serialized: ${buffer.length} bytes`);

const decoded = messages.Record.decode(buffer);

console.log(decoded.name);

Protocol Buffers vs JSON vs XML

Protobuf in the gRPC Ecosystem

gRPC uses Protocol Buffers as its Interface Definition Language (IDL) and message format:

syntax = "proto3";

package users.v1;

service UserService {

 rpc GetUser(GetUserRequest) returns (GetUserResponse);

 rpc ListUsers(ListUsersRequest) returns (stream GetUserResponse);

 rpc CreateUser(CreateUserRequest) returns (GetUserResponse);

}

message GetUserRequest {

 int32 id = 1;

}

message GetUserResponse {

 int32  id      = 1;

 string name    = 2;

 string email   = 3;

 int32  age     = 4;

 bool   active  = 5;

 double balance = 6;

}

message ListUsersRequest {

 int32 page_size = 1;

 string page_token = 2;

}

message CreateUserRequest {

 string name    = 1;

 string email   = 2;

 int32  age     = 3;

}

Recommended Field Naming Practices

Protobuf style guide recommends lowercase_with_underscores for field names.

Frequently Asked Questions

• Does the tool upload my data?

  No. All conversion happens locally in your browser using JavaScript. Your CSV data never leaves your device.

• What is Protocol Buffers?

  Protocol Buffers (Protobuf) is Google's language-neutral serialization format. You define data structures in .proto files, then generate typed code for 15+ programming languages. It is the default format for gRPC.

• What is the difference between proto2 and proto3?

  proto3 is the current default. It has simpler syntax, no required fields, and built-in JSON mapping. proto2 supports required/optional field modifiers and extensions. Use proto3 for new projects.

• How does the tool infer protobuf types from CSV?

  The tool analyzes cell values in each column. Columns with only integers become int32, decimals become double, true/false becomes bool, and everything else becomes string. Large integers may be inferred as int64.

• Can I edit the generated .proto file?

  Yes. Copy the output and modify it. Add package, option, enum, service, repeated fields, oneof, map, and nested messages as needed.

• What happens with empty CSV cells?

  Empty cells are treated as the default value for their inferred type. The field is still included in the message definition.

• Can I use this for gRPC service definitions?

  The tool generates message definitions. To create a full gRPC service, add service blocks with rpc methods manually, using the generated messages as request/response types.

• What CSV formats are supported?

  Standard CSV with comma delimiters. Enable "First Row as Header" to use column names as protobuf field names.

• How do I compile the .proto file?

  Use protoc (the Protocol Buffer compiler):

  # Python protoc --python_out=. data.proto # Go protoc --go_out=. data.proto # Java protoc --java_out=src/main/java data.proto # C++ protoc --cpp_out=. data.proto # C# protoc --csharp_out=. data.proto

• Is there a file size limit?

• The tool processes data entirely in your browser. Files up to 10 MB typically convert without issues on modern hardware.