How can I write one after another JSON data

I am working on a website scraper. I can send only 1 JSON data to JSON file regularly. I want to write one after another JSON data, so I need to keep hundreds of data in a single JSON file. like this

[
{
"id": 1321931,
"name": "Mike"
},
{
"id": 32139219,
"name": "Melissa"
},
{
"id": 8421921,
"name": "Jordan"
},
{
"id": 4291901,
"name": "David"
}
] 

but output like this. When I send new data, just the first JSON data update itself.

[
{
"id": 1,
"name": "Mike"
}
]

here is the code:

package main

import (
    "encoding/json"
    "fmt"
    "html/template"
    "io/ioutil"
    "log"
    "math/rand"
    "net/http"
    "os"
    "strings"

    "github.com/gocolly/colly"
)

type Info struct {
    ID   int    `json:"id"`
    Name string `json:"name"`
}

var tpl *template.Template
var name string
var stonf Info
var allInfos []Info
var id int

var co = colly.NewCollector()

func main() {

    fmt.Println("Started...")
    allInfos = make([]Info, 1)

    id = rand.Intn((99999 - 10000) + 10000)

    // Reading Data From Json
    data, err := ioutil.ReadFile("stocky.json")
    if err != nil {
        fmt.Println("ERROR 1 JSON", err)
    }
    // Unmarshal JSON data
    var d []Info
    err = json.Unmarshal([]byte(data), &d)
    if err != nil {
        fmt.Println(err)
    }

    tpl, _ = tpl.ParseGlob("templates/*.html")
    http.HandleFunc("/mete", hellloHandleFunc)
    staticHandler := http.FileServer(http.Dir("./css/"))
    http.Handle("/css/", http.StripPrefix("/css", staticHandler))
    http.ListenAndServe("localhost:8080", nil)
}

func hellloHandleFunc(w http.ResponseWriter, r *http.Request) {

    err := r.ParseForm()
    if err != nil {
        log.Fatal(err)
    }

    allInfos[0].ID = id // JSON-PRO

    // GET Price - Fiyat GETİR
    co.OnHTML("div#dp", func(p *colly.HTMLElement) {
        name = p.ChildText("h1#title")
    })
    requestLink := strings.TrimSpace(r.FormValue("input-link"))

    co.Visit(requestLink)

    // FIRST DATA JSON
    enc := json.NewEncoder(os.Stdout)
    enc.SetIndent("", " ")
    enc.Encode(allInfos)

    stonf = Info{
        Name: name,
    }

    fmt.Println("Index Running")
    tpl.ExecuteTemplate(w, "form-copy.html", stonf)
}

func writeJson(data []Info) {
    dataFile, err := json.MarshalIndent(data, "", " ")
    if err != nil {
        log.Println("Could not create JSON", err)
    }

    ioutil.WriteFile("stocky.json", dataFile, 0666)
}

Here is a solution which appends new Info to the list and store in file.
The solution will perform properly only for relatively small list. For large lists, the overhead of writing the entire file each time may be too high. In such case i propose to change the format to ndjson. It will allow to write only the current Info struct instead of the whole list.
I've also added synchronization mechanism to avoid race conditions in case you send multiple HTTP requests at the same time.

I assumed that the identifier must be generated separately for each request, and it is not a problem if collision occur.

package main

import (
	"encoding/json"
	"fmt"
	"html/template"
	"io/ioutil"
	"log"
	"math/rand"
	"net/http"
	"os"
	"strings"
	"sync"

	"github.com/gocolly/colly"
)

type (
	Info struct {
		ID   int    `json:"id"`
		Name string `json:"name"`
	}
	Infos struct {
		List []Info
		sync.Mutex
	}
)

var (
	infos *Infos
	tpl *template.Template
	co = colly.NewCollector()
)

func main() {

	fmt.Println("Started...")

	var err error
	infos, err = readInfos()
	if err != nil {
		log.Fatal(err)
	}

	tpl, _ = tpl.ParseGlob("templates/*.html")
	http.HandleFunc("/mete", hellloHandleFunc)
	staticHandler := http.FileServer(http.Dir("./css/"))
	http.Handle("/css/", http.StripPrefix("/css", staticHandler))
	if err := http.ListenAndServe("localhost:8080", nil); err != nil {
		log.Fatal(err)
	}
}

func hellloHandleFunc(w http.ResponseWriter, r *http.Request) {

	err := r.ParseForm()
	if err != nil {
		log.Fatal(err)
	}
	stonf := Info{
		ID: rand.Intn((99999 - 10000) + 10000),
	}
	// GET Price - Fiyat GETİR
	co.OnHTML("div#dp", func(p *colly.HTMLElement) {
		stonf.Name = p.ChildText("h1#title")
	})
	requestLink := strings.TrimSpace(r.FormValue("input-link"))

	if err := co.Visit(requestLink); err != nil {
		log.Fatal(err)
	}

	if err := infos.AppendAndWrite(stonf); err != nil {
		log.Fatal(err)
	}

	// FIRST DATA JSON
	enc := json.NewEncoder(os.Stdout)
	enc.SetIndent("", " ")
	enc.Encode(stonf)

	fmt.Println("Index Running")
	tpl.ExecuteTemplate(w, "form-copy.html", stonf)
}

func readInfos() (*Infos, error) {
	// Reading Data From Json
	data, err := ioutil.ReadFile("stocky.json")
	if err != nil {
		return nil, err
	}
	var r []Info
	// Unmarshal JSON data
	err = json.Unmarshal([]byte(data), &r)
	if err != nil {
		return nil, err
	}
	return &Infos{List: r}, nil
}

func (i *Infos) AppendAndWrite(info Info) error {
	i.Lock()
	defer i.Unlock()
	i.List = append(i.List, info)
	if err := i.storeLocked(); err != nil {
		return fmt.Errorf("storing info list failed: %w", err)
	}
	return nil
}

func (i *Infos) storeLocked() error {
	dataFile, err := json.MarshalIndent(i.List, "", " ")
	if err != nil {
		return fmt.Errorf("could not marshal infos JSON: %w", err)
	}
	err = ioutil.WriteFile("stocky.json", dataFile, 0666)
	if err != nil {
		return fmt.Errorf("could not write 'stocky.json' file: %w", err)
	}
	return nil
}

There is a standard called JSON lines (https://jsonlines.org/) consisting on only one JSON per line instead of wrapping all in a JSON array.
JSON library from Go stdlib works pretty well with JSON lines on both cases, reading and writing.

Write multiple JSON (one per line):

e := json.NewEncoder(yourWriterFile)
e.Encode(object1)
e.Encode(object2)
//...

Read multiple JSON (one per line or concatenated):

d := json.NewDecoder(yourReaderFile)
d.Decode(&object1)
d.Decode(&object2)
//...

More info: https://pkg.go.dev/encoding/json