json: cannot unmarshal string into Go value of type int

The exact error string

package main

import (
    "encoding/json"
    "fmt"
)

type User struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

func main() {
    data := []byte(`{"id": "42", "name": "Ada"}`) // id is a STRING in the JSON
    var u User
    err := json.Unmarshal(data, &u)
    fmt.Println(err)
    // json: cannot unmarshal string into Go struct field User.id of type int
}

The message names both sides: the JSON type (string) and the Go type it couldn't fit (int), plus the field path (User.id). That tells you exactly which field to fix.

Which JSON values fit which Go fields

Cause 1: the field type is simply wrong

If the JSON genuinely holds a string, number, or bool, make the Go field that type. Match each field to what the payload actually sends:

// JSON: {"id": 42, "active": true, "score": 9.5}
type User struct {
    ID     int     `json:"id"`
    Active bool    `json:"active"`
    Score  float64 `json:"score"`
}

Cause 2: the API sends numbers as strings

Some APIs quote their numbers ("id": "42"). Keep the numeric Go type and add the ,string option to the tag — encoding/json will parse the quoted value:

type User struct {
    ID    int     `json:"id,string"`     // accepts "42"
    Score float64 `json:"score,string"`  // accepts "9.5"
}

Caveat for bool: ,string also works on a bool field, but it only accepts the quoted strings "true" and "false" — not "1"/"0" or "yes"/"no". For those, decode the raw value and convert yourself in a custom UnmarshalJSON.

Cause 3: object vs array (shape mismatch)

cannot unmarshal object into Go value of type []User means the JSON is an object but you unmarshalled into a slice (or the reverse). The payload is usually wrapped — match the destination to it:

// JSON: {"data": [{"id":1}, {"id":2}]}  — an object wrapping an array

var users []User
json.Unmarshal(data, &users)        // ❌ cannot unmarshal object into []User

type Resp struct {
    Data []User `json:"data"`
}
var r Resp
json.Unmarshal(data, &r)            // ✅ r.Data is the slice

Cause 4: a field that varies, or big numbers

For a field whose type changes, defer decoding with json.RawMessage or a custom UnmarshalJSON. For numbers of unknown shape (and to avoid the float64 precision trap when decoding into interface{}), use UseNumber():

dec := json.NewDecoder(bytes.NewReader(data))
dec.UseNumber()                      // numbers -> json.Number, not float64

var m map[string]interface{}
dec.Decode(&m)

// use a safe type assertion — m["id"] may be absent or another type
if n, ok := m["id"].(json.Number); ok {
    id, _ := n.Int64()                   // exact, no precision loss
    fmt.Println(id)
}

Nullable fields: handling JSON null

An API that sends {"age": null} is a frequent trigger. A plain value field decodes null as the zero value, so you can't tell "missing/null" from "actually zero." Use a pointer (or a database/sql Null type) when that distinction matters:

// JSON: {"age": null}
type User struct {
    Age *int `json:"age"`        // nil when null; non-nil pointer to 0 when 0
}

// database/sql alternative when reading from a DB:
type Row struct {
    Age sql.NullInt64            // .Valid is false when the value was null
}

What interface{} decodes JSON into

When you decode into interface{} or map[string]interface{}, Go maps each JSON type to a fixed Go type. Knowing this table prevents the wrong type assertion that causes a panic or a follow-on error:

Catch unexpected fields with DisallowUnknownFields

By default Go silently ignores JSON keys that have no matching struct field, which hides typos and schema drift. Make an unknown key an error during decoding:

dec := json.NewDecoder(r)
dec.DisallowUnknownFields()
if err := dec.Decode(&v); err != nil {
    // json: unknown field "xyz" — a key your struct doesn't define
}

Debugging checklist

• ✓ Read both types in the message — the JSON type and the Go field type
• ✓ JSON value genuinely that type? Change the struct field to match
• ✓ API quotes its numbers? Add ,string to the struct tag
• ✓ "object into []T" / "array into struct"? Fix the destination shape (often a wrapper)
• ✓ Field varies by response? Use json.RawMessage or a custom UnmarshalJSON
• ✓ Big integers via interface{}? Use Decoder.UseNumber() to avoid float64
• ✓ Field can be null? Use a pointer (*int) or a sql.Null* type
• ✓ Want unknown keys to error? Decoder.DisallowUnknownFields()
• ✓ Confirm the real value types in the JSON Formatter