Paste JSON on the left; the JSON to Go struct output appears here.
A user with an address, orders, a null and a timestamp
Your JSON is sent to our server to generate the Go code. It is not written to a database and our code does not log it. Results are cached in memory for up to 1 hour. Remove secrets, tokens and personal data before pasting.
Three steps take you from a JSON sample to Go types you can decode with encoding/json. The JSON to Go struct converter infers every type from the sample you paste.
Paste a JSON object or array into the JSON to Go struct converter, or open a .json file. If the JSON is invalid, the error shows the position; fix it or validate your JSON first.
{
"id": 1,
"user_name": "ann",
"email": "[email protected]",
"is_active": true,
"score": 9.5,
"created_at": "2026-10-09T10:00:00Z",
"tags": [
"a",
"b"
],
"address": {
"street": "1 Main",
"geo": {
"lat": 1.5,
"lng": 2.5
}
},
"orders": [
{
"order_id": 10,
"total": 12.5,
"note": null
},
{
"order_id": 11,
"total": 3,
"note": "x"
}
]
}The JSON to Go struct conversion returns one named struct per JSON object. The top-level type is always RootType, and every field keeps its original key in a json tag. Check numeric types, pointer fields and time.Time fields against your real data.
import "time"
type RootType struct {
ID int64 `json:"id"`
UserName string `json:"user_name"`
Email string `json:"email"`
IsActive bool `json:"is_active"`
Score float64 `json:"score"`
CreatedAt time.Time `json:"created_at"`
Tags []string `json:"tags"`
Address Address `json:"address"`
Orders []Order `json:"orders"`
}
type Address struct {
Street string `json:"street"`
Geo Geo `json:"geo"`
}
type Geo struct {
Lat float64 `json:"lat"`
Lng float64 `json:"lng"`
}
type Order struct {
OrderID int64 `json:"order_id"`
Total float64 `json:"total"`
Note *string `json:"note"`
}Copy the JSON to Go struct output or download it as a .go file, then paste the types into a file of your package. The output has no package clause, so keep the package line your file already has.
Every JSON value needs a concrete Go type. This is the mapping the JSON to Go struct converter uses, based only on the sample you paste.
| JSON value | Go type |
|---|---|
| String | string |
| Whole number, e.g. 42 | int64 |
| Number with a fractional part, e.g. 9.5 | float64 |
| true / false | bool |
| Object | Named struct, e.g. Address |
| Array of objects | Slice of a named struct, e.g. []Order |
| Array of strings or numbers | []string, []int64, … |
| ISO 8601 timestamp, e.g. 2026-10-09T10:00:00Z | time.Time (adds import "time") |
| null in one sample, a string in another | *string |
| Key missing from some array elements | Pointer with omitempty, e.g. *bool |
| Empty array, or null everywhere | []interface{} / interface{} |
The converter picks int64 when every sample value is whole and float64 as soon as one has a fractional part (total with 12.5 and 3 becomes float64). 1.0 counts as whole, and an integer above 2^53 becomes float64. Decoding 1.5 into an int64 field fails, so paste a representative sample or edit the type.
ISO 8601 strings such as 2026-10-09T10:00:00Z become time.Time, and the JSON to Go struct output starts with import "time". Other formats, such as 10/09/2026, fail to decode; use string for those.
How field names, json tags, omitempty and pointers in the JSON to Go struct output work with encoding/json.
encoding/json only fills exported fields, so keys become PascalCase names: user_name → UserName, order_id → OrderID, 2nd → The2Nd. The original key stays in a tag such as json:"user_name", so decoding and encoding still use the JSON names.
omitempty is added automatically, only to keys missing from some elements of an array, and those fields become pointers so a missing value decodes to nil. It only affects json.Marshal, which leaves a nil field out; reading is unchanged.
A field that is null in one sample and a string in another becomes *string with a plain json:"note" tag. A nil pointer stands for null, and a field that is null everywhere becomes interface{}.
Dashes, spaces, digits and acronyms all become exported names, and each tag keeps the exact key.
// {"first-name":"a","type":"x","2nd":1,"HTTPStatus":200,"user id":5,"":0}
type RootType struct {
FirstName string `json:"first-name"`
Type string `json:"type"`
The2Nd int64 `json:"2nd"`
HTTPStatus int64 `json:"HTTPStatus"`
UserID int64 `json:"user id"`
Empty int64 `json:""`
}A top-level array becomes type RootType []RootTypeElement. a is in every element and stays int64; b and c are missing from some, so they become pointers with omitempty.
// [{"a":1,"b":"x"},{"a":2},{"a":3,"c":true}]
type RootType []RootTypeElement
type RootTypeElement struct {
A int64 `json:"a"`
B *string `json:"b,omitempty"`
C *bool `json:"c,omitempty"`
}Decode JSON into the JSON to Go struct output with json.Unmarshal, or stream an HTTP response with json.NewDecoder.
Pass a pointer to RootType. This usage code is hand-written and checked with go vet against the sample structs.
var user RootType
if err := json.Unmarshal(data, &user); err != nil {
log.Fatal(err)
}
fmt.Println(user.UserName, user.CreatedAt, len(user.Orders))
// From an HTTP response
resp, err := http.Get(url)
if err != nil {
log.Fatal(err)
}
defer resp.Body.Close()
if err := json.NewDecoder(resp.Body).Decode(&user); err != nil {
log.Fatal(err)
}Cases where JSON to Go struct output needs a manual change before you rely on it.
A mixed array needs a custom UnmarshalJSON method, or use []any or json.RawMessage for the field (example below).
Paste the types into an existing .go file; the output does not include a package clause or helper functions, only type definitions and import "time" when needed.
A key that is an empty string becomes a field named Empty, but encoding/json will not map it back to the empty key. Keys in scripts without capital letters, such as 名前, become unexported fields that encoding/json ignores. Rename those fields and keep the tag.
For an array that mixes numbers, strings, null and objects, the JSON to Go struct converter creates a VElement struct with one pointer per type (Integer, String, VClass). It has no json tags and no UnmarshalJSON method, so json.Unmarshal returns an error for this field.
// {"v":[1,"a",null,{"x":1}]}
type RootType struct {
V []VElement `json:"v"`
}
type VClass struct {
X int64 `json:"x"`
}
type VElement struct {
Integer *int64
String *string
VClass *VClass
}Need the same JSON in another language, or a check before the JSON to Go struct conversion?
Generate TypeScript interfaces from JSON for a front end that reads the same API.
Generate C# classes from JSON with System.Text.Json or Newtonsoft.Json attributes.
If the converter reports a syntax error, validate your JSON first to find and fix the syntax problem.
Common questions about json tags, omitempty, pointers and number types in the generated Go code
Edit, format, and beautify JSON
Validate, fix, and inspect JSON
Compare, measure, and map JSON
Convert JSON to other formats
Convert other formats to JSON
Convert, format, fix, and minify XML
Generate code and format other languages