Convierte datos JSON a interfaces TypeScript, structs Go, dataclasses Python, schemas Zod o JSON Schema. Pega JSON, obtén salida tipificada con soporte anidado.
Pega JSON a la izquierda para generar tipos TypeScript.
Pega JSON y obtén interfaces TypeScript, structs Go, dataclasses Python, schemas Zod o JSON Schema en segundos. La herramienta analiza tus datos, infiere tipos para cada campo y genera interfaces nombradas para objetos anidados. Sin registro, sin llamadas al servidor, sin dependencias.
Un generador de JSON a TypeScript toma un objeto JSON de ejemplo y produce las definiciones de tipo TypeScript correspondientes (interfaces, type aliases o schemas Zod) infiriendo el tipo de cada campo. En lugar de escribir manualmente los tipos que reflejan tus respuestas de API o objetos de configuración, pegas un ejemplo JSON representativo y la herramienta genera los tipos automáticamente. Esto ahorra tiempo, reduce errores y maneja casos borde como objetos anidados, arrays de tipos mixtos y campos nullable.
.json.ts, .go, .py o .jsonProduce interfaces TypeScript estándar. Mejor para respuestas de API, objetos de configuración y cuando necesitas declaration merging.
Produce declaraciones type. Mejor para union types, mapped types y cuando necesitas más flexibilidad en tus definiciones de tipo.
Produce un JSON Schema (draft-07) a partir de tus datos. El schema incluye propiedades tipificadas, listas de campos requeridos, distinción entero vs. flotante y schemas recursivos de objetos anidados.
Produce structs Go con tags JSON struct. Cada campo obtiene un nombre exportado PascalCase y un tag json:"...". Los campos opcionales incluyen omitempty.
Produce dataclasses Python con type annotations. Los campos usan nombres snake_case, los campos faltantes se escriben como Optional[T] = None.
Produce schemas Zod con type inference. Cada objeto se convierte en un z.object(), los campos faltantes usan z.optional(), el tipo TypeScript se exporta con z.infer.
La herramienta mapea valores JSON a tipos TypeScript, Go, Python, Zod y JSON Schema:
| Valor JSON | Tipo TypeScript | Tipo Go | Tipo Python | Tipo Zod | Tipo JSON Schema |
|---|---|---|---|---|---|
"hola" |
string |
string |
str |
z.string() |
"string" |
42 |
number |
int |
int |
z.number() |
"integer" |
3.14 |
number |
float64 |
float |
z.number() |
"number" |
true / false |
boolean |
bool |
bool |
z.boolean() |
"boolean" |
null |
null |
interface{} |
None |
z.null() |
"null" |
{} |
Record<string, unknown> |
map[string]interface{} |
Dict[str, Any] |
z.record(z.unknown()) |
{ "type": "object", "additionalProperties": true } |
[] |
unknown[] |
[]interface{} |
List[Any] |
z.array(z.unknown()) |
{ "type": "array", "items": {} } |
[{ ... }] |
TypeName[] |
[]StructName |
List[TypeName] |
z.array(TypeName) |
{ "type": "array", "items": { ... } } |
{ key: "val" } |
interface TypeName { ... } |
type StructName struct { ... } |
@dataclass class TypeName: ... |
z.object({...}) |
{ "type": "object", "properties": { ... } } |
Los objetos anidados obtienen nombres basados en ruta para evitar colisiones. Dado este JSON:
{
"user": {
"name": "Alice",
"address": { "city": "NYC" }
}
}
La herramienta produce:
interface RootUserAddress {
city: string;
}
interface RootUser {
name: string;
address: RootUserAddress;
}
interface Root {
user: RootUser;
}
La convención de nombres usa la ruta de clave en PascalCase: user.address se convierte en RootUserAddress.
Pega una respuesta de API de ejemplo y genera tipos para tus llamadas fetch. Funciona con APIs REST, respuestas GraphQL y cualquier endpoint JSON.
Genera tipos para archivos de configuración, variables de entorno u objetos de ajustes. La herramienta maneja configuraciones anidadas con múltiples niveles de profundidad.
Nothing you paste leaves this tab. Every tool runs entirely in your browser — no upload, no server, no account.