Entrada (JSON)

Salida (esquema .proto)

Qué hace esta herramienta

¿Tienes un payload JSON real — una respuesta de API de muestra, el cuerpo de un webhook, una fila de un almacén NoSQL — y quieres modelarlo como un mensaje de Protocol Buffers? Escribir el esquema a mano es lento y se presta a errores, sobre todo cuando hay objetos y arrays anidados. Este conversor recorre el JSON, infiere tipos Protobuf para cada campo y emite un esquema proto3 limpio que puedes pegar directo en tu proyecto.

La inferencia de tipos sigue lo que tú escribirías a mano: string para cadenas, bool para booleanos, int32 para enteros que caben en 32 bits, int64 para el resto, double para números no enteros, repeated <T> para arrays de un único tipo de elemento (un mensaje anidado reutilizado para arrays de objetos) y bloques message anidados para objetos anidados. JSON no distingue una struct de un map, así que todos los objetos salen como mensajes anidados — cambia uno por map<K, V> a mano si tus datos son realmente un mapa.

Los nombres de campo se convierten de camelCase o kebab-case al snake_case que es convención en Protobuf. Los números de campo se asignan 1, 2, 3, … en el orden de declaración. La salida es proto3 válido — pégalo en un archivo .proto, ejecuta protoc o buf, y tendrás código generado en el lenguaje que elijas. La conversión corre entera en tu navegador — ni el JSON, ni los nombres de campo, ni los valores se envían a ningún sitio.

Cómo usarlo

Tres pasos. Funciona con cualquier objeto JSON bien formado — respuestas de API, entradas de log, archivos de fixtures, lo que sea.

Pega tu JSON

Mete el JSON en el editor de la izquierda. La raíz tiene que ser un objeto ({ ... }) — envuelve un array en un objeto primero si tus datos arrancan con array, p. ej. { "items": [...] }. Usa datos realistas: cuanto más representativa sea la muestra, mejor encajarán los tipos inferidos con lo que quieres a largo plazo.

Si tu JSON tiene claves sin comillas, comas finales u otras rarezas, pásalo primero por el JSON Fixer — Protobuf necesita un objeto limpio para trabajar.

Pulsa Convertir

Haz clic en el botón verde Convertir. El conversor recorre cada clave del JSON, elige un tipo Protobuf, construye bloques message anidados para los objetos anidados y emite el esquema con syntax = "proto3"; arriba. Los números de campo se asignan en el orden de aparición.

Usa el .proto

Copia el esquema en un archivo .proto de tu repo. Revisa los tipos inferidos — donde la muestra JSON estaba vacía (array vacío, null) verás un comentario marcando que el tipo es una conjetura. Ajusta lo que haga falta y luego ejecuta protoc o buf generate para producir código en tu lenguaje.

Cuándo te ahorra tiempo de verdad

Modelar una API de terceros como Protobuf

Un proveedor devuelve JSON. Tu servicio almacena Protobuf. Coge una respuesta real, pégala aquí, obtén un esquema de partida para el tipo y luego refínalo. Mejor que leer la documentación y teclear 50 campos a mano.

Migrar un servicio basado en JSON a gRPC

Estás moviendo un microservicio HTTP+JSON a gRPC. Cada forma de petición y respuesta necesita un .proto. Convierte cada payload capturado en un esquema Protobuf, pégalos en un único archivo y tienes el contrato esbozado.

Arrancar un módulo de Buf

¿Montando un módulo nuevo de Buf y necesitas esquemas realistas para empezar? Convierte tus fixtures JSON existentes y usa la salida como semilla para tus archivos .proto — mucho más rápido que escribirlos desde cero.

Escribir fixtures de test para código Protobuf

Tu equipo tiene datos de test en JSON. El código nuevo consume Protobuf. Genera el <code>.proto</code> a partir del JSON y deja que tu codegen construya los tipos — tus fixtures y tu código se mantienen sincronizados.

Preguntas habituales

¿Mi JSON se envía a algún sitio?

No. El conversor corre entero en tu navegador como JavaScript. Tu JSON — claves, valores, lo que sea sensible — nunca sale de tu máquina. Abre las DevTools y mira la pestaña Network mientras pulsas Convertir. Cero peticiones.

¿Cómo elige entre int32, int64 y double?

Para valores enteros, comprueba si el valor cabe en un rango con signo de 32 bits (-2^31 a 2^31-1). Si sí, int32. Si no, int64. Los números no enteros siempre acaban como double. Si sabes que tus datos son sin signo o quieres un ancho específico como fixed32, edita la salida — mira la tabla de tipos escalares para todos los tipos numéricos disponibles y sus compromisos de codificación en el cable.

¿Cuándo un objeto se vuelve un map en lugar de un mensaje anidado?

Siempre un mensaje anidado — nunca un map. JSON no distingue una struct de un map, así que adivinar uno u otro acierta más o menos la mitad de las veces. Si tus datos son realmente un mapa clave-valor (p. ej. metadatos, headers, feature flags), abre la salida y cambia message Foo { ... } por map<string, V> foo = N; a mano. El cambio es mecánico y obvio en cuanto ves tus datos.

¿Y los null y los arrays vacíos?

Ambos producen un comentario en la salida marcando que el tipo se adivinó a partir de una muestra degenerada. null tira a string con una nota de "nullable". Los arrays vacíos tiran a repeated string con una nota de "empty array". Sustituye esos tipos por lo que de verdad esperes.

¿Por qué los arrays de tipos mixtos salen como repeated string?

Protobuf no soporta listas heterogéneas directamente. Si tu array JSON tiene tipos mixtos (algunas cadenas, algunos números), no hay un equivalente Protobuf limpio — necesitas o bien google.protobuf.Value, un oneof, o reorganizar la forma de los datos. El conversor lo marca con un comentario para que decidas tú.

¿Maneja JSON profundamente anidado?

Sí. Cada objeto anidado se vuelve un message anidado con un nombre derivado en PascalCase. La profundidad de anidado solo está acotada por la profundidad de la pila, no por el conversor — incluso respuestas de API muy anidadas se convierten sin problemas.

¿Puedo hacer ida y vuelta JSON ↔ Protobuf con estas dos herramientas?

Casi. JSON a Protobuf te da un esquema; Protobuf a JSON te da una muestra. Las formas coinciden en los campos donde la muestra JSON tenía un valor representativo. Donde el JSON tenía null o arrays vacíos, el tipo Protobuf inferido es una conjetura y la ida y vuelta solo será exacta después de que arregles el tipo.

Herramientas relacionadas

Si andas peleándote con JSON y esquemas, estas combinan bien:

Conversor de JSON a Protobuf