Use a Shifter com Go

package main

import (
	"crypto/rand"
	"encoding/hex"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func newClient(country, city string) *http.Client {
	sidBytes := make([]byte, 4)
	rand.Read(sidBytes)
	sid := hex.EncodeToString(sidBytes)

	proxyURL, _ := url.Parse(fmt.Sprintf(
		"customer-USERNAME-country-%s-city-%s-sid-%s-ttl-300:PASSWORD@p.shifter.io:443",
		country, city, sid,
	))

	return &http.Client{
		Timeout: 30 * time.Second,
		Transport: &http.Transport{
			Proxy:                 http.ProxyURL(proxyURL),
			MaxIdleConnsPerHost:   16,
			IdleConnTimeout:       90 * time.Second,
			TLSHandshakeTimeout:   10 * time.Second,
			ResponseHeaderTimeout: 20 * time.Second,
		},
	}
}

func main() {
	c := newClient("uk", "london")

	for _, path := range []string{"/login", "/dashboard", "/orders"} {
		req, _ := http.NewRequest("GET", "https://example.co.uk"+path, nil)
		req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36")

		resp, err := c.Do(req)
		if err != nil {
			fmt.Println("error:", err)
			continue
		}
		body, _ := io.ReadAll(resp.Body)
		resp.Body.Close()
		fmt.Println(path, resp.StatusCode, len(body), "bytes")
	}
}

package main

import (
	"fmt"

	"github.com/go-resty/resty/v2"
)

type Product struct {
	ID    int     `json:"id"`
	Name  string  `json:"name"`
	Price float64 `json:"price"`
}

func main() {
	client := resty.New().
		SetProxy("customer-USERNAME-country-de-sid-456DEF:PASSWORD@p.shifter.io:443").
		SetRetryCount(3).
		SetRetryWaitTime(2_000_000_000). // 2s in ns
		SetHeader("User-Agent", "Mozilla/5.0 (Macintosh) AppleWebKit/537.36")

	var products []Product
	resp, err := client.R().
		SetResult(&products).
		Get("https://api.example.de/products")

	if err != nil || !resp.IsSuccess() {
		fmt.Println("error:", err, resp.Status())
		return
	}

	for _, p := range products {
		fmt.Printf("%d %s — %.2f EUR\n", p.ID, p.Name, p.Price)
	}
}

package main

import (
	"fmt"
	"log"

	"github.com/gocolly/colly/v2"
)

func main() {
	c := colly.NewCollector(
		colly.AllowedDomains("example.com"),
		colly.UserAgent("Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36"),
	)

	if err := c.SetProxy(
		"customer-USERNAME-country-fr-city-paris-sid-789GHI:PASSWORD@p.shifter.io:443",
	); err != nil {
		log.Fatal(err)
	}

	c.OnHTML("article.post", func(e *colly.HTMLElement) {
		fmt.Println(e.ChildText("h2"), "->", e.ChildAttr("a", "href"))
	})

	c.OnError(func(r *colly.Response, err error) {
		fmt.Printf("error %d: %v\n", r.StatusCode, err)
	})

	c.Visit("https://example.com/blog")
}

package main

import (
	"context"
	"fmt"
	"time"

	"github.com/chromedp/chromedp"
)

func main() {
	opts := append(chromedp.DefaultExecAllocatorOptions[:],
		chromedp.ProxyServer("http://p.shifter.io:443"),
		chromedp.Flag("headless", true),
	)

	allocCtx, cancel := chromedp.NewExecAllocator(context.Background(), opts...)
	defer cancel()

	ctx, cancel := chromedp.NewContext(allocCtx)
	defer cancel()

	ctx, cancel = context.WithTimeout(ctx, 30*time.Second)
	defer cancel()

	var html string
	err := chromedp.Run(ctx,
		// chromedp doesn't natively prompt for proxy auth — use a Chrome
		// extension or run a sidecar that injects credentials, or use
		// Shifter's IP-whitelist auth instead of user/pass.
		chromedp.Navigate("https://example.com"),
		chromedp.WaitVisible("body", chromedp.ByQuery),
		chromedp.OuterHTML("html", &html),
	)

	if err != nil {
		fmt.Println("error:", err)
		return
	}
	fmt.Println(len(html), "bytes")
}