JSON to Go Struct Converter

What is generated, and why the type is a guess

Go decodes JSON into a struct using the standard encoding/json package. The struct declares the field names and types; a json tag maps each Go field back to the original key:

type User struct {
	ID       int    `json:"id"`
	UserName string `json:"user_name"`
	IsActive bool   `json:"is_active"`
}

The tag matters because Go requires exported fields — starting with a capital letter — for encoding/json to see them, while JSON keys are usually snake_case or camelCase. Without the tag, decoding user_name into UserName silently produces an empty string.

How to generate structs

1. Paste a representative sample Ideally one that includes optional fields. Every element of an array is inspected, so a key that appears only in the third element is still discovered.
2. Name the root struct Nested types are named from their key. A customer object becomes a Customer struct.
3. Choose how whole numbers are typed int, int64, or float64 for everything. See below for why this is a decision rather than a detection.
4. Read the review notes Null-only fields, empty arrays, conflicting types, oversized integers and date-looking strings are all called out individually.

Field merging across arrays

Most JSON-to-Go tools read the first element of an array and stop. That produces a struct that fails on real data. Given this input:

{
  "items": [
    { "sku": "AB-100", "qty": 2 },
    { "sku": "CD-200", "qty": 1, "gift_note": "Happy birthday" },
    { "sku": "EF-300", "qty": 4, "gift_note": null }
  ]
}

A first-element-only tool generates a struct with SKU and Qty, and gift_note disappears entirely. Every element is inspected here, so the field is found and marked optional because it is absent from one of the three:

type Item struct {
	SKU      string  `json:"sku"`
	Qty      int     `json:"qty"`
	GiftNote *string `json:"gift_note,omitempty"`
}

Why the pointer

Go has no null. An absent string and an empty string both give you "", so a plain string field cannot tell you which happened. A *string can: nil means the key was absent, and a pointer to "" means it was present and empty.

That distinction matters for PATCH endpoints, where "field not supplied" and "field set to empty" must behave differently. It costs an extra dereference everywhere else, so the option is there to turn it off.

Why omitempty

omitempty only affects encoding, not decoding. With it, a zero value is left out of the output JSON. Note the well-known trap: omitempty treats false, 0 and "" as empty, so a genuine false disappears from encoded output. Combining omitempty with a pointer is the usual way to keep that distinction.

Numbers: the decision JSON forces on you

JSON has exactly one number type. There is no integer, no float, no decimal — just number. So {"price": 10} and {"price": 10.0} are byte-different but parse identically, and no tool can tell them apart after parsing.

Two practical rules follow. For a field that could be fractional even if your sample happens to be whole, set it to float64 by hand. For money, neither int nor float64 is right — store minor units as an integer, or use a decimal library.

There is a third option worth knowing: json.Number keeps the literal text and defers the decision, which is useful when you need to round-trip a payload without altering its numbers.

Examples of naming decisions

Go has firm naming conventions, and the generator follows them rather than doing a plain capitalisation.

The initialism list is the one from the Go project's own code review comments — ID, URL, API, HTTP, JSON, SQL, UUID and around thirty more. Writing Id and Url is legal Go but reads as non-idiomatic to reviewers.

Identical object shapes are deduplicated: if billing_address and shipping_address have the same keys, one Address-style struct is generated and both fields use it. Different shapes that happen to share a key name get numbered names instead of silently colliding.

What you should still change by hand

• Timestamps. "2026-03-14T09:00:00Z" is generated as string. Change it to time.Time and encoding/json will parse RFC 3339 automatically. A non-RFC-3339 format needs a custom UnmarshalJSON.
• Enumerated values. A status field of "active" is a string here. A named type with constants gives you compile-time safety.
• Null-only fields. Generated as any, because a field that is null in every sample reveals nothing about its real type.
• Empty arrays. [] becomes []any. Supply a sample containing at least one element to get a real element type.
• Fields with conflicting types. If one element has "count": 5 and another "count": "5", no single Go type fits. The field becomes any and is flagged. This usually indicates an API inconsistency worth reporting.
• Struct placement. Generated types are emitted parents-first in one block. Split them across files as your package layout requires.

Use cases

• Consuming a third-party API. Capture one response and get a decodable struct without hand-typing forty fields.
• Writing a webhook handler. Paste a sample delivery payload and you have the request body type.
• Typing a config file. A JSON config becomes a struct you can unmarshal at startup and validate.
• Building test fixtures. Generate the type, then construct instances in tests instead of embedding raw JSON strings.
• Auditing an undocumented payload. The struct is a compact schema summary, and the review notes point at the fields that vary between records.
• Migrating from map[string]any. Replace untyped map access with a real struct and let the compiler find the mistakes.

Working in a different language? JSON to Java generates classes or records from the same model. For the JSON itself, the JSON Formatter validates and indents, and the JSON Schema Validator checks it against a schema.

Privacy

Parsing and code generation run entirely in your browser. The JSON is not uploaded, which matters when the sample is a real API response containing customer data. Usage analytics record only the number of generated structs and the number-type setting, never the JSON or the output.