How to convert JSON to a struct

I call a third-party API and I get the following JSON:

{"amount":1.0282E+7}

When I want to convert it I got an error:

> Blocjson: cannot unmarshal number 1.0282E+7 into Go struct field MiddleEastAccountToCardResponse.amount of type int64

I want to convert this JSON to following struct in Go:

type Response struct {
	Amount int64 `json:"amount"`
}

Since you haven't explained your exact desired outcome, we can only guess. But you have three general approaches to this:

1. Unmarshal to a float type instead of an integer type. You can perhaps convert to an int later, if you need an int.

2. Unmarshal to a json.Number type, which preserves the complete JSON representation and its precision, and can be converted to an int or float as needed.

3. Use a custom unmarshaler, which converts from a float to an int type for you.

All three are demonstrated here:

package main

import (
	"fmt"
	"encoding/json"
)

const input = `{"amount":1.0282E+7}`

type ResponseFloat struct {
    Amount float64 `json:"amount"`
}

type ResponseNumber struct {
    Amount json.Number `json:"amount"`
}

type ResponseCustom struct {
    Amount myCustomType `json:"amount"`
}

type myCustomType int64

func (c *myCustomType) UnmarshalJSON(p []byte) error {
    var f float64
    if err := json.Unmarshal(p, &f); err != nil {
        return err
    }
    *c = myCustomType(f)
    return nil
}

func main() {
	var x ResponseFloat
	var y ResponseNumber
	var z ResponseCustom
	
	if err := json.Unmarshal([]byte(input), &x); err != nil {
	    panic(err)
	}
	if err := json.Unmarshal([]byte(input), &y); err != nil {
	    panic(err)
	}
	if err := json.Unmarshal([]byte(input), &z); err != nil {
	    panic(err)
	}
	fmt.Println(x.Amount)
	fmt.Println(y.Amount)
	fmt.Println(z.Amount)
}

See it in the playground.

Amount field in your struct is a int64, but number you're trying to parse from string is float (in scientific notation).

Try this:

type Response struct {
    Amount float64 `json:"amount"`
}

Modify your code as follows:

package main

import (
	"encoding/json"
	"fmt"
)

func main() {

	var data = []byte(`{"amount":1.0282E+7}`)
	var res Response
	json.Unmarshal(data, &res)
	fmt.Println(res)

}

type Response struct {
	Amount float64 `json:"amount"`
}

Output:

{1.0282e+07}