JSON to Go Struct Generator

Example Input

{
  "id": 1,
  "username": "priya_singh",
  "email": "priya@learnhubly.com",
  "is_active": true,
  "score": 98.5,
  "profile": {
    "bio": "Principal Software Engineer",
    "skills": ["Go", "React", "TypeScript"]
  },
  "deleted_at": null
}

Example Output

package main

import "encoding/json"

type Profile struct {
	Bio    string   `json:"bio"`
	Skills []string `json:"skills"`
}

type User struct {
	ID        int64    `json:"id"`
	Username  string   `json:"username"`
	Email     string   `json:"email"`
	IsActive  bool     `json:"is_active"`
	Score     float64  `json:"score"`
	Profile   Profile  `json:"profile"`
	DeletedAt *string  `json:"deleted_at"`
}

// Usage:
// var user User
// err := json.Unmarshal(data, &user)
// or
// err := json.NewDecoder(resp.Body).Decode(&user)

Does it support nested objects?

Yes. Nested JSON objects are generated as separate named Go struct types and composed correctly in the parent struct. A JSON field whose value is an object becomes a field of a named struct type — for example a profile object in the JSON becomes a Profile struct in Go with its own fields and json tags. Deeply nested structures are handled recursively, with each level of nesting generating its own struct type. After generating, rename the struct types from the generic generated names to meaningful domain names like User, Profile, Address, or whatever the data represents.

Are JSON tags included?

Yes. Every struct field is generated with the correct json struct tag mapping the PascalCase Go field name to the original JSON field name. A JSON field named user_id generates UserId int64 `json:"user_id"` in Go. A field named createdAt generates CreatedAt string `json:"createdAt"`. The json tag is what tells encoding/json how to map between the JSON field names and the Go struct field names — without it, the package uses the Go field name verbatim which would not match snake_case or camelCase JSON field names.

How do I unmarshal JSON into the generated struct?

Two approaches depending on your input. For JSON as a byte slice: var result YourStruct; err := json.Unmarshal(data, &result). For an HTTP response body: var result YourStruct; err := json.NewDecoder(resp.Body).Decode(&result); don't forget defer resp.Body.Close(). For a JSON string: err := json.Unmarshal([]byte(jsonString), &result). If the JSON is an array at the top level, unmarshal into a slice: var results []YourStruct; err := json.Unmarshal(data, &results). Always check the returned error — a non-nil error means the JSON did not match the struct structure.

What Go types are inferred for different JSON values?

JSON strings become string. JSON integers become int64 (not int, because int64 handles the full range of JSON integer values). JSON floats become float64. JSON booleans become bool. JSON arrays become []ElementType with the element type inferred from the array contents. JSON null values become pointer types — *string, *int64, *bool, or *StructName — since a nil pointer represents the absence of a value, which is the Go idiom for nullable fields. JSON nested objects become named struct types. If a JSON field contains different types in different elements, the tool uses interface{} as a fallback type.

What is the omitempty struct tag option and when should I use it?

The omitempty option in a json tag — like `json:"fieldName,omitempty"` — tells encoding/json to omit the field from the JSON output when marshaling if the field has its zero value (empty string, zero integer, false boolean, nil pointer, empty slice). It has no effect during unmarshaling — it only affects json.Marshal output. Use omitempty on fields that should not appear in the marshaled JSON when they are absent or unset — for example optional fields in a request body or fields that have meaningful default behavior when absent. Do not use omitempty on fields that should always be present in the output even when they are zero or empty.

How do I handle JSON arrays at the top level?

If the API returns a top-level JSON array, the generated struct describes one element. Unmarshal into a slice of that struct: var items []YourStruct; err := json.Unmarshal(data, &items). For paginated responses with a wrapper like {data: [...], total: 100}, generate the struct from the full wrapper object — the tool will create a struct with a Data field of type []ItemStruct and a Total field of type int64.

Can I use the generated struct with popular Go HTTP client libraries?

Yes. The generated structs work with any Go HTTP client that uses encoding/json for response decoding. With the standard library net/http, use json.NewDecoder(resp.Body).Decode(&result). With the resty library, use client.R().SetResult(&result).Get(url) and resty handles the JSON decoding automatically. With go-resty, the approach is similar. With the fasthttp library, use json.Unmarshal(ctx.Response.Body(), &result). The generated structs are plain Go structs with standard encoding/json tags — they work with any library that respects the encoding/json interface.

What is the difference between using a struct and using map[string]interface{} for JSON in Go?

map[string]interface{} lets you decode any JSON without defining a struct — encoding/json maps JSON fields to map keys with interface{} values representing the JSON values. This is flexible but forces you to type-assert every value you access: userMap["name"].(string), userMap["age"].(float64). Type assertion failures cause panics at runtime. Struct-based decoding gives you compile-time type safety — accessing user.Name is always a string without any assertion. For any JSON structure you will access frequently, a struct is faster to access, safer, and produces better code. Use map[string]interface{} only when the JSON structure is genuinely unknown at compile time, such as when forwarding arbitrary JSON between services.