JSON to Go: structs that unmarshal on the first try

The generated shape

A converter turns each JSON object into a struct, each array into a slice, and infers a Go type per value. Nested objects become named types rather than anonymous blobs, which keeps the signature of your decoding code readable:

                type Container struct {
  Name  string `json:"name"`
  Image string `json:"image"`
  Ports []struct {
    ContainerPort int `json:"containerPort"`
  } `json:"ports"`
}
              

The `json` tags are the important part. Go’s decoder is case-insensitive when matching field names, but `containerPort` and `ContainerPort` do not align without a tag, and any key that is not a valid Go identifier — `app.kubernetes.io/name`, for instance — cannot be matched at all without one.

Numbers, nulls and the two classic traps

• Numbers — inference produces `int` for whole values, but JSON has no integer type. A field that is `3` today may be `3.5` tomorrow, so IDs and money are safer as `float64`, `string` or `json.Number` depending on your needs.
• Nulls — a key that can be `null` should be a pointer (`*string`) so you can tell “absent” from “empty”.
• Timestamps — an RFC 3339 string decodes cleanly into `time.Time`; a Unix epoch number does not, so keep those as `int64` and convert explicitly.
• Unknown fields — `json.Decoder` ignores extras by default; use `DisallowUnknownFields` when you would rather fail loudly.

Generate from two or three responses when you can. Fields that are sometimes missing become pointers, and that decision is much easier to make from evidence than from memory.

From struct to working code

With the structs in place, decoding is three lines and the compiler enforces the access paths from there. A common pattern is to decode into the generated struct, then map into your domain type so that the JSON shape can change without rippling through the application. Tag the generated file with the endpoint it came from, and regenerate when the response changes rather than editing it by hand — hand-edited generated code is the version that nobody dares to regenerate later.

Generate locally

The payloads worth generating Go structs from are usually real API responses, and real responses carry tokens and customer data. A browser-based JSON to Go conversion keeps the payload in the tab — no upload, no retention question — which makes generating from production data a normal step rather than a policy exception.