How do I convert JSON to a Go struct?

Paste your JSON, choose Go as the target language, and the tool emits a struct for every object. Each field is exported in PascalCase (user_id → UserID) with the original key preserved in a `json:"user_id"` tag, so it round-trips through encoding/json. Nested objects become their own structs, and arrays become slices such as []string.

How do I generate a Pydantic model from JSON?

Pick “Python (Pydantic v2)”. Each JSON object becomes a class that extends BaseModel, string maps to str, whole numbers to int, decimals to float, and nested objects to their own models. Keys that are not valid Python identifiers (or use camelCase) get a Field(alias="originalKey") so the model still parses the wire data. Optional and null fields become Optional[T] = None.

What type does a JSON number map to in Go, Python, or Rust?

JSON has one number type, so the tool inspects the value. A number with no fractional part maps to an integer type (int64/i64/long by default, or 32-bit if you turn off the 64-bit toggle); a number with a decimal point maps to float64/f64/double. If one sample has 300 and another 300.5 for the same key, the type widens to the floating-point type to fit both.

How are nested JSON objects turned into structs or classes?

Every object becomes a named type. The name comes from the key in PascalCase, a “profile” object becomes Profile, and array elements are singularised, so an “orders” array of objects yields an Order type. Structurally identical objects reuse one type, and declarations are printed children-before-parents so the file compiles top to bottom.

How do I handle null or missing fields when generating code from JSON?

A key that is missing from some objects in an array is marked optional; a key whose value is null is marked nullable. Both render as the language's optional form: a pointer with omitempty in Go, Optional[T] = None in Python, Option in Rust, a boxed nullable type in Java, T? in Kotlin and C#. A field that is only ever null has no concrete type, so it maps to the language's any/object type rather than a guess.

Does the generated code compile?

Yes. Types are printed children-before-parents, invalid identifiers are sanitised while the original key is kept in the serialization tag, and reserved words are escaped (Rust type → type_, C# class → @class, Kotlin `object`). The tool also runs a structural check that your original JSON satisfies the generated types and shows it as the “Accepts input” badge.

Is my JSON uploaded anywhere?

No. Parsing and code generation run entirely in your browser with JavaScript. There is no server call, no API key, and no upload. Once the page has loaded you can go offline and it still works. That matters when the sample contains real customer, payment, or API-key data.

Why does this not create enums from string values like "status": "open"?

Inferring an enum from a single sample would be a guess, the field might legitimately hold any string. This tool only emits what the JSON proves, so "status": "open" becomes a string field. If you need TypeScript output instead, the JSON to TypeScript Converter is a sibling tool linked below.

Developer · Utility

JSON to Code Generator, Go, Python, Java, Kotlin, C# & Rust

Paste a JSON sample and get typed data structures in the language you need, Go structs, Python dataclasses or Pydantic v2 models, Java records, Kotlin data classes, C# classes, or Rust structs. Nested objects, merged arrays, and optional or null fields are handled for you. Runs entirely in your browser; nothing is uploaded.

By Induwara Ashinsana· Co-Founder, Ryzera TechnologiesUpdated Jul 16, 2026

JSON to Go

Runs in your browser

Target language

Root type name

JSON input

274 characters. Paste an API response, then pick a language above.

Go output

type Profile struct {
	City       string `json:"city"`
	PostalCode int64  `json:"postal_code"`
}

type Order struct {
	ID    string  `json:"id"`
	Total float64 `json:"total"`
	Paid  *bool   `json:"paid,omitempty"`
	Note  *string `json:"note,omitempty"`
}

type Root struct {
	UserID   int64    `json:"user_id"`
	Name     string   `json:"name"`
	IsActive bool     `json:"is_active"`
	Roles    []string `json:"roles"`
	Profile  Profile  `json:"profile"`
	Orders   []Order  `json:"orders"`
}

Status

Valid JSON

Parsed per RFC 8259

Types generated

3 Go types: Profile, Order, Root

Accepts input

Verified

Your JSON structurally satisfies the generated types.

Input size

274

characters parsed

Inferred types

Field path	JSON type	Mapped type	Flags
user_id	number (integer)	int64	—
name	string	string	—
is_active	boolean	bool	—
roles	array	[]string	—
profile	object	Profile	—
profile.city	string	string	—
profile.postal_code	number (integer)	int64	—
orders	array	[]Order	—
orders[].id	string	string	—
orders[].total	number (decimal)	float64	—
orders[].paid	boolean	*bool	optional
orders[].note	string	*string	optional

All parsing and code generation runs in your browser. Sources: Go, Python, Pydantic v2, Java (Jackson), Kotlin, C# (System.Text.Json), and Rust (serde) specifications, cited below the tool.

How it works

This is a deterministic source-to-source transformation, not a guess. The JSON is parsed once with JSON.parse following RFC 8259, which defines the six JSON value types, object, array, string, number, boolean, and null. A single recursive pass infers a language-neutral shape for every node, then a per-language emitter prints code using each language's own specification for types and serialization.

Primitives. A JSON string maps to string/str/String, and a boolean to the language's bool type. Because JSON has only one number type, the tool checks the literal: a whole number becomes an integer type (int64, i64, long), a decimal becomes a floating type (float64, f64, double). The 64-bit toggle switches integers between 64- and 32-bit width.
Objects become named types. Each object is emitted as a struct, record, data class, or class. The name is the PascalCased key, a profile object becomes Profile, and an orders array of objects yields a singularised Order element type. Structurally identical objects reuse one type; genuine name clashes get a numeric suffix.
Arrays are merged.Every element is inferred and the schemas are unioned: object fields are merged, and a key present in only some elements is marked optional. A key seen as an integer in one element and a decimal in another widens to the floating type. An empty array has nothing to infer, so its element falls back to the language's any/Value type.
Optional and nullable. A missing key is optional; a null value is nullable. Both render as the idiomatic optional form, a pointer with omitempty in Go, Optional[T] = None in Python, Option<T> in Rust, a boxed nullable in Java, and T? in Kotlin and C#.
Naming and safety.Field names are cased to each language's convention (exported PascalCase for Go, snake_case for Python and Rust, camelCase for Java and Kotlin), while the original wire name is preserved in a json tag, @JsonProperty, serde rename, @SerialName, or [JsonPropertyName]. Keys that start with a digit or contain hyphens are sanitised (first-name → first_name), and reserved words are escaped.

Because the rules are fixed, identical input and identical options always produce byte-identical output. As a cross-check, the generator runs a structural assignability test, it confirms your original JSON value satisfies the types it just produced, and shows the result as the Accepts input badge. Every mapping is traceable to the language and serializer specifications cited below.

Worked examples

Go struct, nested object + typed array

Go · 64-bit ints · tags on

Input JSON

{ "user_id": 42, "name": "Nimal",
  "is_active": true,
  "roles": ["admin", "editor"],
  "profile": { "city": "Colombo", "postal_code": 70000 } }

Generated code

type Profile struct {
	City       string `json:"city"`
	PostalCode int64  `json:"postal_code"`
}

type Root struct {
	UserID   int64    `json:"user_id"`
	Name     string   `json:"name"`
	IsActive bool     `json:"is_active"`
	Roles    []string `json:"roles"`
	Profile  Profile  `json:"profile"`
}

42 has no fractional part, so it maps to int64; roles is an array of strings → []string.
profile is extracted into its own Profile struct and emitted before Root (children-first).
user_id exports to UserID (the “id” initialism is upper-cased) with the wire name kept in the json tag.

Pydantic v2, array merge + widening

Python (Pydantic v2) · tags on

Input JSON

{ "orders": [
    { "id": "ORD-1", "total": 4500.5, "paid": true },
    { "id": "ORD-2", "total": 300, "note": "gift" }
] }

Generated code

class Order(BaseModel):
    id: str
    total: float
    paid: Optional[bool] = None
    note: Optional[str] = None


class Root(BaseModel):
    orders: list[Order]

The two order objects merge into one Order model. paid is missing from element 2 and note from element 1, so both become Optional.
total is 4500.5 (decimal) in one element and 300 (whole) in the other, so the type widens to float.
Fields with defaults are printed after those without, satisfying Python's default-ordering rule.

Rust, key sanitisation with serde

Rust · tags on

Input JSON

{ "first-name": "Amaya", "2fa": false }

Generated code

#[derive(Debug, Serialize, Deserialize)]
pub struct Root {
    #[serde(rename = "first-name")]
    pub first_name: String,
    #[serde(rename = "2fa")]
    pub two_fa: bool,
}

first-name is not a valid Rust identifier, so it is snake-cased to first_name.
2fa starts with a digit, so the leading digit becomes a word → two_fa.
Both keep the original wire name via #[serde(rename)], so the struct round-trips to the source JSON.

Frequently asked questions

Sources & references

The type-mapping rules on this page were last cross-checked against the language and serializer specifications above on 2026-07-16. The generator is deterministic, so its output can be reproduced exactly from the same input and options.

Related tools

Utility

TOTP / 2FA Generator

Turn a Base32 secret into the live 6- or 8-digit TOTP an authenticator app would show right now, with a countdown to the next code, or generate a fresh secret plus a scannable otpauth QR to set up 2FA. RFC 6238, runs entirely in your browser.

Open tool

Utility

UTM Builder

Build correctly-formatted UTM campaign URLs and see which GA4 Default Channel Group each link will land in, entirely in your browser.

Open tool

Utility

Soundex Calculator

Convert any name to its American Soundex code (e.g. Robert → R163) using the official U.S. National Archives rules, with a full step-by-step derivation of how each letter is mapped, skipped or collapsed. Runs entirely in your browser.

Open tool

Comments & feedback

Spotted a bug or want an improvement? Tell us, our team reviews every comment, and good ideas get built. Comments are public and anonymous.

Found a JSON shape that generates wrong code, or want another language target?

Email me at [email protected] , most fixes ship within 24 hours.