JSON to Go Struct: 5 Approaches Compared (2026)

The example JSON

We will run the same payload through every generator so you can see the exact output each one produces. It covers the patterns that matter — nested objects, arrays, booleans, decimals, integers, and ISO 8601 timestamps.

{
  "order": {
    "id": "ORD-9921",
    "total": 1249.99,
    "currency": "INR",
    "paid": true,
    "items": [
      { "sku": "PROD-441", "quantity": 2, "unit_price": 499.99 }
    ],
    "customer": {
      "id": 42,
      "email": "jane@example.com"
    },
    "placed_at": "2026-05-10T09:30:00Z"
  }
}

Read that carefully. total is a JSON number with a decimal, id is a string, customer.id is an integer, and placed_at is an ISO 8601 timestamp. Each generator handles those types slightly differently.

Approach 1: Manual struct writing

Write the structs by hand, guided by the JSON shape. Slow for 50-field payloads, perfect for small APIs where you want every type chosen on purpose.

package main

import "time"

type Item struct {
    SKU       string  `json:"sku"`
    Quantity  int     `json:"quantity"`
    UnitPrice float64 `json:"unit_price"`
}

type Customer struct {
    ID    int    `json:"id"`
    Email string `json:"email"`
}

type Order struct {
    ID       string    `json:"id"`
    Total    float64   `json:"total"`
    Currency string    `json:"currency"`
    Paid     bool      `json:"paid"`
    Items    []Item    `json:"items"`
    Customer Customer  `json:"customer"`
    PlacedAt time.Time `json:"placed_at"`
}

type Response struct {
    Order Order `json:"order"`
}

Best for: stable internal APIs with 10 fields or fewer, or hot paths where a generated converter function adds latency you measured and care about.

Approach 2: mholt/json-to-go (the original)

mholt.github.io/json-to-go is the canonical online generator, written by Matt Holt and open source since 2015 (github.com/mholt/json-to-go). The page is pure JavaScript — paste JSON on the left, Go on the right, nothing leaves your browser. Toggles for omitempty and inline types are right there in the header.

Output for our example JSON:

// Generated by mholt/json-to-go
type AutoGenerated struct {
    Order struct {
        ID       string  `json:"id"`
        Total    float64 `json:"total"`
        Currency string  `json:"currency"`
        Paid     bool    `json:"paid"`
        Items    []struct {
            Sku       string  `json:"sku"`
            Quantity  int     `json:"quantity"`
            UnitPrice float64 `json:"unit_price"`
        } `json:"items"`
        Customer struct {
            ID    int    `json:"id"`
            Email string `json:"email"`
        } `json:"customer"`
        PlacedAt time.Time `json:"placed_at"`
    } `json:"order"`
}

Best for: the one-off case. You have a JSON response, you want a struct in 10 seconds, you do not need to wire generation into CI.

Approach 3: quicktype (CLI + web)

quicktype.io is the most widely used multi-language type generator in 2026. The web UI is convenient; the CLI is what matters for repeat use. quicktype supports 20+ output languages from the same JSON or JSON Schema input, and it is the only generator on this list that handles multi-sample inference well.

Output for our example JSON:

// Generated by quicktype (quicktype.io)
type Response struct {
    Order Order `json:"order"`
}

type Order struct {
    ID       string    `json:"id"`
    Total    float64   `json:"total"`
    Currency string    `json:"currency"`
    Paid     bool      `json:"paid"`
    Items    []Item    `json:"items"`
    Customer Customer  `json:"customer"`
    PlacedAt time.Time `json:"placed_at"`
}

type Item struct {
    Sku       string  `json:"sku"`
    Quantity  int64   `json:"quantity"`
    UnitPrice float64 `json:"unit_price"`
}

type Customer struct {
    ID    int64  `json:"id"`
    Email string `json:"email"`
}

CLI usage:

# Install quicktype globally
npm install -g quicktype

# Generate Go structs from a JSON file
quicktype --lang go --src response.json --out types.go

# Generate from a URL (quicktype fetches the JSON)
quicktype --lang go --src-lang json \
  https://api.example.com/order/9921 --out types.go

# Custom package name + top-level type
quicktype --lang go --package api --top-level Response \
  --src response.json --out types.go

Best for: generating Go types as part of a build pipeline, especially when the same JSON shape needs TypeScript or Python types too.

Approach 4: JSONLint json-to-go

jsonlint.com/json-to-go wraps a similar single-sample generator on top of their JSON validator. The output is named structs (not inline anonymous like mholt), and tags are produced with omitempty by default on optional-looking fields.

Output for our example JSON is functionally identical to quicktype's, with two differences: JSONLint emits int instead of int64 for small integer fields, and it emits string for ISO 8601 timestamps instead of time.Time. If you prefer to parse timestamps explicitly in a constructor, that default works for you. If you want zero-cost time.Time, you will be doing a find-and-replace.

Approach 5: gojson CLI (ChimeraCoder)

github.com/ChimeraCoder/gojson is a stdin-friendly Go CLI tool. Install it with go install, then pipe JSON into it. It has been around since 2014 and is the choice of teams that already have Go on PATH and do not want to add a Node toolchain.

# Install gojson (ChimeraCoder)
go install github.com/ChimeraCoder/gojson/gojson@latest

# Pipe JSON to stdin
cat response.json | gojson -name Response -pkg api > types.go

# From a remote URL
curl -s https://api.example.com/order/9921 | gojson -name Response > types.go

The output is named structs with json tags, similar to quicktype. gojson is single-sample only — no multi-sample inference — but it is the lightest install path when you already have a Go environment and need to script generation in a Makefile or shell script.

Four struct-tag pitfalls every Go developer hits

1. Typos in the tag key are silently ignored

The most painful one. encoding/json does not validate tag keys. A typo like josn:"name" falls back to the capitalized Go field name.

type Order struct {
    ID    string `josn:"id"`     // typo: "josn" — silently ignored, uses field name "ID"
    Total float64 `json:"total"`
}

// Marshals as: {"ID":"ORD-9921","total":1249.99}
// Camel-case field name leaks into JSON output. Linters like govet --json catch this.

go vet catches some of these via the structtag analyzer, but only for known tag keys. Treat go vet as a CI gate; do not rely on review.

2. Unexported fields are invisible to encoding/json

internalID with lowercase first letter is unexported. The marshaler cannot see it, the unmarshaler cannot fill it. No error. The fix is to export it (InternalID) and add a json tag if you want a different on-the-wire name.

3. omitempty drops false the same as absent on bools

On a bool field, omitempty means "skip when false." If you need to distinguish "explicit false" from "absent," use *bool:

type Customer struct {
    ID       int    `json:"id"`
    Email    string `json:"email"`
    Phone    string `json:"phone,omitempty"`    // omits "" from output
    Verified *bool  `json:"verified,omitempty"` // pointer keeps false distinct from absent
}

4. Embedded struct field promotion has rules you should know

An anonymous embedded struct gets its exported fields promoted to the outer struct's JSON. Useful for sharing a BaseEntity across types:

type BaseEntity struct {
    ID        string    `json:"id"`
    CreatedAt time.Time `json:"created_at"`
}

type Order struct {
    BaseEntity        // anonymous embedded — fields promoted at the top level
    Total    float64  `json:"total"`
    Currency string   `json:"currency"`
}

// JSON output:
// { "id": "...", "created_at": "...", "total": 1249.99, "currency": "INR" }

Gotcha: embed an unexported struct and its fields will not be promoted (golang/go#54322 documents the asymmetry between embedded structs and embedded interfaces). And if the embedded struct has a json tag of its own, the inner fields are nested under that tag's name instead of promoted — that is sometimes what you want, but rarely what an auto-generator produces.

Comparison table

Which one should you use?

Three rules of thumb:

• One-off, small payload, browser-friendly: mholt/json-to-go. Paste, copy, done.
• Repeat use or part of a build: quicktype CLI. Multi-sample widening is the killer feature.
• Go-only toolchain, no Node: gojson via go install.

Skip JSONLint if your JSON is sensitive. Skip the generators entirely and write structs by hand if the API is small and stable and you want every type chosen on purpose.