DEV Community

HAU
HAU

Posted on

Stop Writing Structs by Hand: Generate Go, Java, TypeScript, and 8 More from JSON

#json #tooling #code #go

Automatic Code Generation from JSON

JSON Buddy's Code Generator converts any JSON object into a ready-to-use struct or class definition. Paste JSON, pick a language, copy the output. Done in seconds.

Supported languages: Go · Java · TypeScript · Python · Rust · C# · PHP · Ruby · C · C++ · Zig

How to Use It

  1. Go to json-formatter.net
  2. Paste your JSON into the editor
  3. Click Code Gen in the toolbar
  4. Select your target language
  5. Click Copy

That's it. No account, no API call, no upload. The generation runs entirely in your browser.

Examples

Input JSON 

{
  "id": 42,
  "username": "alice_dev",
  "email": "alice@example.com",
  "is_active": true,
  "score": 98.5,
  "address": {
    "city": "Berlin",
    "country": "DE",
    "zip": "10115"
  },
  "tags": ["admin", "beta-user"]
}
Enter fullscreen mode Exit fullscreen mode

Go 

package main

type Root struct {
    Id       int64   `json:"id"`
    Username string  `json:"username"`
    Email    string  `json:"email"`
    IsActive bool    `json:"is_active"`
    Score    float64 `json:"score"`
    Address  Address `json:"address"`
    Tags     []string `json:"tags"`
}

type Address struct {
    City    string `json:"city"`
    Country string `json:"country"`
    Zip     string `json:"zip"`
}
Enter fullscreen mode Exit fullscreen mode

Go structs are generated with proper json:"..." tags, exported field names (PascalCase), and nested objects as separate named structs.

TypeScript 

interface Root {
  id: number;
  username: string;
  email: string;
  is_active: boolean;
  score: number;
  address: Address;
  tags: string[];
}

interface Address {
  city: string;
  country: string;
  zip: string;
}
Enter fullscreen mode Exit fullscreen mode

Python 

from __future__ import annotations
from dataclasses import dataclass
from typing import Any, List, Optional

@dataclass
class Address:
    city: str
    country: str
    zip: str

@dataclass
class Root:
    id: int
    username: str
    email: str
    is_active: bool
    score: float
    address: Address
    tags: List[str]
Enter fullscreen mode Exit fullscreen mode

Python output uses @dataclass with snake_case field names. Dependency classes are emitted before the root class.

Rust 

use serde::{Deserialize, Serialize};

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Address {
    pub city: String,
    pub country: String,
    pub zip: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Root {
    pub id: i64,
    pub username: String,
    pub email: String,
    #[serde(rename = "is_active")]
    pub is_active: bool,
    pub score: f64,
    pub address: Address,
    pub tags: Vec<String>,
}
Enter fullscreen mode Exit fullscreen mode

Rust output includes #[derive(Serialize, Deserialize)] and #[serde(rename = "...")] attributes when field names differ from snake_case.

Java 

import java.util.List;

public class Root {
    private int id;
    private String username;
    private String email;
    private boolean isActive;
    private double score;
    private Address address;
    private List<String> tags;

    public int getId() { return id; }
    public void setId(int id) { this.id = id; }
    public String getUsername() { return username; }
    public void setUsername(String username) { this.username = username; }
    // ... getters/setters for all fields
}
Enter fullscreen mode Exit fullscreen mode

C 

using System.Collections.Generic;
using System.Text.Json.Serialization;

public class Root
{
    public int Id { get; set; }
    public string Username { get; set; }
    public string Email { get; set; }
    [JsonPropertyName("is_active")]
    public bool IsActive { get; set; }
    public double Score { get; set; }
    public Address Address { get; set; }
    public List<string> Tags { get; set; }
}
Enter fullscreen mode Exit fullscreen mode

Zig 

const Address = struct {
    city:    []const u8,
    country: []const u8,
    zip:     []const u8,
};

const Root = struct {
    id:        i64,
    username:  []const u8,
    email:     []const u8,
    is_active: bool,
    score:     f64,
    address:   Address,
    tags:      [][]const u8,
};
Enter fullscreen mode Exit fullscreen mode

What It Handles Automatically

Nested objects → Each nested object becomes its own struct/class, named after the key.

Arrays → The element type is inferred from the first item. string[] in TypeScript, Vec<String> in Rust, []string in Go, etc.

Type inference → Integer vs float is detected from the actual value. 42 → int64/int/i64. 3.14 → float64/double/f64.

Naming conventions → Each language gets its own convention: PascalCase fields in Go and C#, camelCase in Java, snake_case in Python and Rust, original key names in TypeScript.

Null values → Typed as the language's nullable/optional type: interface{} in Go, Optional[Any] in Python, object? in C#.

Real-World Workflow

The most common use case: you're integrating a third-party API and need to model the response.

# Fetch the response, copy it
curl https://api.example.com/users/1 | pbcopy

# Paste into JSON Buddy, click Code Gen, select Go
# Copy the generated struct into your codebase
Enter fullscreen mode Exit fullscreen mode

What used to take 10-20 minutes of careful typing (and probably a typo or two) now takes 30 seconds.

Try It

👉 json-formatter.net — click Code Gen after pasting your JSON.

All generation is client-side. Your JSON never leaves the browser.

Also in this series:

Top comments (0)