Go interface conversion panic — interface {} is X, not Y

What causes this error

A type assertion `x.(T)` at runtime checks whether the concrete type stored in interface `x` is exactly `T`. If it's not, it panics with 'interface conversion: interface {} is {actual}, not {expected}'. This happens when asserting the wrong type on `interface{}` values from JSON decoding, function parameters, or context values. The single-return form `x.(T)` always panics on failure; the two-return form `x, ok := x.(T)` returns `false` for `ok` without panicking.

How to fix it

1. 01

   step 1

   Use the comma-ok idiom for safe type assertions

   The two-return form of type assertion never panics. Always use it when you're not certain of the concrete type.

   var val interface{} = 42
   
   // BAD — panics if val is not string
   s := val.(string)
   
   // GOOD — safe assertion
   s, ok := val.(string)
   if !ok {
       log.Printf("expected string, got %T: %v", val, val)
       return
   }

   Copy
2. 02

   step 2

   Use a type switch for multiple possible types

   When a value could be one of several types, a `switch v := x.(type)` handles each case cleanly without risking a panic.

   func describe(val interface{}) string {
       switch v := val.(type) {
       case string:
           return fmt.Sprintf("string: %q", v)
       case int:
           return fmt.Sprintf("int: %d", v)
       case float64:
           return fmt.Sprintf("float64: %f", v)
       case bool:
           return fmt.Sprintf("bool: %t", v)
       case nil:
           return "nil"
       default:
           return fmt.Sprintf("unknown type: %T", v)
       }
   }

   Copy
3. 03

   step 3

   Understand JSON decoding types for interface{}

   When `json.Unmarshal` decodes into `interface{}`, it maps JSON types to specific Go types. JSON numbers become `float64`, not `int`. JSON objects become `map[string]interface{}`, not a struct. Asserting the wrong type on a decoded value is one of the most common sources of this panic.

   var data interface{}
   json.Unmarshal([]byte(`{"count": 42}`), &data)
   
   m := data.(map[string]interface{})  // ✅ JSON objects → map[string]interface{}
   count := m["count"].(int)           // ❌ JSON numbers → float64, not int!
   
   // Fix:
   count := m["count"].(float64)       // ✅ correct Go type for JSON number
   countInt := int(count)              // convert to int after assertion
   
   // Better: unmarshal into a typed struct instead of interface{}
   type Response struct {
       Count int `json:"count"`
   }
   var r Response
   json.Unmarshal([]byte(`{"count": 42}`), &r)
   fmt.Println(r.Count)  // int, no assertion needed

   Copy
4. 04

   step 4

   Avoid using interface{} / any as a shortcut — use typed parameters

   If you find yourself writing many type assertions, the function signature should use the actual type. `interface{}` parameters require runtime type checking; typed parameters are checked at compile time.

   // BAD — requires runtime type assertion everywhere
   func save(data interface{}) error {
       user, ok := data.(User)
       if !ok { return errors.New("not a user") }
       return db.Save(user)
   }
   
   // GOOD — compile-time type safety
   func save(user User) error {
       return db.Save(user)
   }
   
   // For generic behavior across types, use generics (Go 1.18+):
   func save[T User | Product](item T) error {
       return db.Save(item)
   }

   Copy

How to verify the fix

• All type assertions use the comma-ok form or are inside a type switch.
• No single-return assertions `x.(T)` remain unless you are 100% certain of the concrete type.
• JSON decoding uses typed structs instead of `interface{}`.