JSON to Go Struct — Typed Fields, json Tags, Pointers, Zero Upload

Real-world use cases

• Type a third-party API response without hand-writing structs

  You're integrating the GitHub API and the user object has 30+ fields. Curl the endpoint once, paste the JSON here, set the root name to `GitHubUser`, copy the output into `internal/github/types.go`. The nested `plan` object lifts out as `GitHubUserPlan` automatically, and `html_url` becomes `HTMLURL` with the right tag. Now `json.Unmarshal(body, &u)` fills a fully-typed struct instead of a `map[string]interface{}` you have to type-assert all over.

• Generate request/response DTOs for a new endpoint

  A teammate sends you a sample JSON body for the `/orders` POST they're building. Paste it, name the root `CreateOrderRequest`, turn on `,omitempty` so optional fields don't bloat the marshalled payload. Paste the response sample too as `CreateOrderResponse`. Two structs, fully tagged, committed to `api/dto.go` before either of you writes the handler.

• Decide pointers vs values for a nullable webhook payload

  A vendor's webhook sometimes includes `cancelled_at` and sometimes omits it. Log the first few payloads, paste them as a JSON array, and the optional-field detection flags `cancelled_at`. Turn on Pointers and it becomes `*string`, so in your handler `if e.CancelledAt != nil` cleanly distinguishes "cancelled" from "still active" — instead of guessing whether an empty string means absent.

• Migrate a map[string]interface{} blob to a real type

  Old code does `var data map[string]interface{}` and reaches in with `data["user"].(map[string]interface{})["id"].(float64)`. Capture one representative response, paste it, generate the struct, replace the map. The `.(float64)` casts that bit you (JSON numbers decode as float64 into `interface{}`) disappear — `int` and `float64` are now inferred at the field level.

• Build fixtures and config types for a Go service

  Your service reads a `config.json`. Paste it, name the root `Config`, get `Config`, `ConfigServer`, `ConfigServerTLS` nested structs with `int` ports and `bool` flags. Drop them in `config.go`, write `json.NewDecoder(f).Decode(&cfg)`, and your config is type-checked at compile time instead of failing at runtime on a typo'd key.

Common pitfalls

• Pasting a single object and expecting some fields to be optional. A single object has no missing-key signal, so every field is required. Optional/pointer inference only kicks in across an array of objects where some elements carry a key and others don't. To explore optionality from one sample, wrap it as `[{...}]`.

• Turning on ,omitempty for a field where 0 / false / empty is a real value. With omitempty, a `Count int` that you set to 0 simply won't appear in the marshalled JSON — the receiver can't tell "count is zero" from "count was never sent". Use a pointer (`*int`) plus omitempty when you genuinely need that distinction.

• Assuming int64 is always correct for IDs. If your IDs arrive as JSON *strings* (Stripe `cus_123`, many UUID APIs), they infer as `string`, not int64 — and that's correct. int64 only applies to numeric JSON values. Don't manually retype a string ID to int64; you'll break unmarshalling.

• Treating a field that's only ever null as a typed field. `{"meta": null}` gives `Meta interface{}` because null carries no type information. If you know the real shape, feed a non-null sample (`{"meta": {"k": 1}}`) so the tool can infer a proper struct.

• Pasting JSON5 / JSON-with-comments / trailing commas. We use strict `JSON.parse`, so comments, unquoted keys, and trailing commas all error out. Strip them first, or pipe through a JSON formatter as a pre-step.

Privacy