Post Marshaled JSON data as URL Encoded Form Data

I'm trying to send a POST request by converting an auth structure to application/x-www-form-urlencoded data.

package main

import (
	"bytes"
	"encoding/json"
	"io/ioutil"
	"log"
	"net/http"
)

type Payload struct {
	Username string `json:"username"`
	Password string `json:"password"`
	GrantType string `json:"grant_type"`
	Scope string `json:"scope"`
}

func main() {

	var endpoint string = "https://api.io/v1/oauth/token"

	jsonPay := &Payload{
		Username: "email",
		Password: "pass",
		GrantType: "password",
		Scope: "SPACE SEPARATED STRINGS",
	}

	//byteArr, err := json.Marshal(jsonPay)
    //if err != nil {
    //    log.Printf("Unable to map structure\n%v", err)
    //}

    payloadBuf := new(bytes.Buffer)
	json.NewEncoder(payloadBuf).Encode(jsonPay)

	req, err := http.NewRequest("POST", endpoint, payloadBuf)
	if err != nil {
		log.Fatal(err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Add("Accept", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	log.Printf(string(body))

}

I've tried:

1. Sending a JSON encoded payload buffer, which returns

   {"error":"invalid_request","error_description":"Missing grant type"}
   

2. Using bytes.NewReader with the marshaled JSON object, which also returns

   {"error":"invalid_request","error_description":"Missing grant type"}
   

3. Using strings.NewReader with the JSON encoded payload buffer, which returns

   cannot use payloadBuf (variable of type *bytes.Buffer) as type string in argument to strings.NewReader
   

The curl request looks like:

curl --request POST \
  --url https://api.io/v1/oauth/token \
  --header 'Content-Type: application/x-www-form-urlencoded' \
  --data 'username=email' \
  --data 'password=pass' \
  --data 'grant_type=password' \
  --data 'scope=SPACE SEPARATED STRINGS'

and works with:

package main

import (
	"io/ioutil"
	"log"
	"net/http"
	"net/url"
	"strings"
)

func main() {

	const endpoint string = "https://api.io/v1/oauth/token"

	payload := url.Values{
		"username":   {"email"},
		"password":   {"pass"},
		"grant_type": {"password"},
		"scope":      {"SPACE SEPARATED STRINGS"},
	}

	req, err := http.NewRequest("POST", endpoint, strings.NewReader(payload.Encode()))
	if err != nil {
		log.Printf("Unable to perform POST request:\n%v", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Add("Accept", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(string(body))
}

How do I post marshaled JSON data as application/x-www-form-urlencoded

Implemented @RedBlue's suggestion:

package main

import (
	"io/ioutil"
	"log"
	"net/http"
	"strings"
	"net/url"
)

type Payload struct {
	Username string `json:"username"`
	Password string `json:"password"`
	GrantType string `json:"grant_type"`
	Scope string `json:"scope"`
}

func main() {

	const endpoint string = "https://api.io/v1/oauth/token"

	formData := &Payload{
		Username: "email",
		Password: "pass",
		GrantType: "password",
		Scope: "SPACE SEPARATED STRINGS",
	}

	payload := url.Values{
		"username":   {formData.Username},
		"password":   {formData.Password},
		"grant_type": {formData.GrantType},
		"scope":      {formData.Scope},
	}

	req, err := http.NewRequest("POST", endpoint, strings.NewReader(payload.Encode()))
	if err != nil {
		log.Printf("Unable to perform POST request:\n%v", err)
	}
	req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
	req.Header.Add("Accept", "application/json")

	resp, err := http.DefaultClient.Do(req)
	if err != nil {
		log.Fatal(err)
	}
	defer resp.Body.Close()

	body, err := ioutil.ReadAll(resp.Body)
	if err != nil {
		log.Fatal(err)
	}
	log.Println(string(body))
}