Instagram API in Go — net/http, One Envelope Struct, Typed Data

Go — error handling

package main

import (
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"net/http"
	"net/url"
	"os"
	"time"
)

type Envelope struct {
	Success          bool            `json:"success"`
	CreditsCharged   int             `json:"credits_charged"`
	CreditsRemaining int             `json:"credits_remaining"`
	ProcessingTimeMs int             `json:"processing_time_ms"`
	RequestedAt      string          `json:"requested_at"`
	Query            map[string]any  `json:"query"`
	Data             json.RawMessage `json:"data"`
	Error            *APIError       `json:"error"`
}

type APIError struct {
	Code    string `json:"code"`
	Message string `json:"message"`
}

type StatusError struct {
	Status int
	Code   string
	Msg    string
}

func (e *StatusError) Error() string {
	return fmt.Sprintf("%d %s: %s", e.Status, e.Code, e.Msg)
}

// Retryable reports whether another attempt can succeed. Only a 200 is ever
// charged, so a retry costs credits only when it eventually returns 200.
func (e *StatusError) Retryable() bool { return e.Status >= 500 }

func call(ctx context.Context, client *http.Client, path string, q url.Values) (Envelope, error) {
	var env Envelope

	req, err := http.NewRequestWithContext(ctx, http.MethodGet,
		"https://api.socialscrape.dev/v1"+path+"?"+q.Encode(), nil)
	if err != nil {
		return env, err
	}
	req.Header.Set("x-api-key", os.Getenv("INSCRAPE_KEY"))

	res, err := client.Do(req)
	if err != nil {
		return env, err
	}
	defer res.Body.Close()

	if err := json.NewDecoder(res.Body).Decode(&env); err != nil {
		return env, err
	}

	if res.StatusCode != http.StatusOK {
		code, msg := "UNKNOWN", ""
		if env.Error != nil {
			code, msg = env.Error.Code, env.Error.Message
		}
		return env, &StatusError{Status: res.StatusCode, Code: code, Msg: msg}
	}

	return env, nil
}

func callWithRetry(ctx context.Context, client *http.Client, path string, q url.Values) (Envelope, error) {
	var env Envelope
	var err error

	for attempt := 0; attempt < 3; attempt++ {
		env, err = call(ctx, client, path, q)
		if err == nil {
			return env, nil
		}

		var se *StatusError
		if !errors.As(err, &se) || !se.Retryable() {
			return env, err
		}

		time.Sleep(time.Duration(1<<attempt) * time.Second)
	}

	return env, err
}

func main() {
	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
	defer cancel()

	env, err := callWithRetry(ctx, &http.Client{Timeout: 30 * time.Second},
		"/instagram/profile", url.Values{"handle": {"natgeo"}})

	var se *StatusError
	switch {
	case errors.As(err, &se) && se.Code == "ENDPOINT_NOT_FOUND":
		fmt.Println("API route not found")
	case errors.As(err, &se) && se.Code == "INSUFFICIENT_CREDITS":
		fmt.Println("out of credits")
	case err != nil:
		panic(err)
	default:
		var data struct { Profile json.RawMessage `json:"profile"` }
		if err := json.Unmarshal(env.Data, &data); err != nil { panic(err) }
		if string(data.Profile) == "null" {
			fmt.Println("account not found; credits charged:", env.CreditsCharged)
		}
		fmt.Println("credits left:", env.CreditsRemaining)
	}
}