How to get live gold prices in Go

go mod init goldprice-demo
go get github.com/shopspring/decimal

// go: goldprice.go
// curl-equivalent: https://api.goldprice.dev/v1/spot/XAU-USD-SPOT
package main

import (
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"os"
	"sync"
	"time"

	"github.com/shopspring/decimal"
)

const (
	apiBase = "https://api.goldprice.dev"
	timeout = 5 * time.Second
	ttl     = 60 * time.Second
)

// SpotResponse holds the fields we consume from /v1/spot/{symbol}.
type SpotResponse struct {
	Symbol        string          `json:"symbol"`
	QuoteCurrency string          `json:"quote_currency"`
	Price         decimal.Decimal `json:"price"`
	Bid           decimal.Decimal `json:"bid"`
	Ask           decimal.Decimal `json:"ask"`
	IsStale       bool            `json:"is_stale"`
	ComputedAt    string          `json:"computed_at"`
}

var errRateLimited = errors.New("goldprice: 429 rate limited")

type cacheEntry struct {
	resp    SpotResponse
	expires time.Time
}

// Client is safe for concurrent use.
type Client struct {
	apiKey string
	http   *http.Client
	mu     sync.Mutex
	cache  map[string]cacheEntry
}

func NewClient() *Client {
	key := os.Getenv("GOLDPRICE_API_KEY")
	if key == "" {
		panic("GOLDPRICE_API_KEY not set")
	}
	return &Client{
		apiKey: key,
		http:   &http.Client{Timeout: timeout},
		cache:  make(map[string]cacheEntry),
	}
}

// Spot fetches the live spot price. Cached 60s per symbol, retries 3x on 429.
func (c *Client) Spot(symbol string) (SpotResponse, error) {
	c.mu.Lock()
	if e, ok := c.cache[symbol]; ok && time.Now().Before(e.expires) {
		c.mu.Unlock()
		return e.resp, nil
	}
	c.mu.Unlock()

	var out SpotResponse
	var err error
	for attempt := 0; attempt < 3; attempt++ {
		out, err = c.fetch(symbol)
		if err == nil {
			c.mu.Lock()
			c.cache[symbol] = cacheEntry{resp: out, expires: time.Now().Add(ttl)}
			c.mu.Unlock()
			return out, nil
		}
		if !errors.Is(err, errRateLimited) {
			return SpotResponse{}, err
		}
		time.Sleep(time.Duration(1<<attempt) * time.Second) // 1s, 2s, 4s
	}
	return SpotResponse{}, err
}

func (c *Client) fetch(symbol string) (SpotResponse, error) {
	req, err := http.NewRequest(http.MethodGet, apiBase+"/v1/spot/"+symbol, nil)
	if err != nil {
		return SpotResponse{}, err
	}
	req.Header.Set("X-API-Key", c.apiKey)

	resp, err := c.http.Do(req)
	if err != nil {
		return SpotResponse{}, err
	}
	defer resp.Body.Close()

	if resp.StatusCode == http.StatusTooManyRequests {
		return SpotResponse{}, errRateLimited
	}
	if resp.StatusCode != http.StatusOK {
		return SpotResponse{}, fmt.Errorf("goldprice: unexpected status %d", resp.StatusCode)
	}

	var out SpotResponse
	if err := json.NewDecoder(resp.Body).Decode(&out); err != nil {
		return SpotResponse{}, err
	}
	return out, nil
}

func main() {
	c := NewClient()
	r, err := c.Spot("XAU-USD-SPOT")
	if err != nil {
		panic(err)
	}
	fmt.Printf("%s-%s: %s (computed %s)\n", r.Symbol, r.QuoteCurrency, r.Price, r.ComputedAt)
}

go run goldprice.go
# XAU-USD: 4726.01 (computed 2026-06-26T04:49:01.706844+00:00)

c := NewClient()

// USD spot — default
c.Spot("XAU-USD-SPOT")

// INR — Indian gold market (largest retail gold-search globally)
c.Spot("XAU-INR-SPOT")

// EUR — European pricing surfaces
c.Spot("XAU-EUR-SPOT")

// Silver in USD
c.Spot("XAG-USD-SPOT")