How to Use a Proxy in Go: A net/http Client Guide

ProxiesThatWork — Tue, 08 Sep 2026 12:53:04 +0000

If you're building an HTTP client in Go and need to route requests through a proxy, you don't need a third-party library. The standard net/http package handles it natively.

Set the Proxy field on your http.Transport, point it at your proxy's URL with http.ProxyURL(), and pass that transport into your http.Client. That's the whole setup.

Here's the minimal version:

package main

import (
    "fmt"
    "io"
    "log"
    "net/http"
    "net/url"
)

func main() {
    proxyURL, err := url.Parse("http://proxy-host:proxy-port")
    if err != nil {
        log.Fatal(err)
    }

    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }

    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()

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

    fmt.Println(string(body))
}

That's it. Every request made with client now goes through the proxy.

Adding authentication

Most paid proxies need a username and password. Go supports this two ways.

The simplest is embedding credentials directly in the proxy URL:

proxyURL, err := url.Parse("http://username:password@proxy-host:proxy-port")

Go reads the userinfo portion of the URL and automatically attaches a Proxy-Authorization header to every request. You don't have to build that header yourself.

If you'd rather keep credentials out of a URL string (useful when they come from environment variables or a secrets manager), build the URL struct directly instead:

proxyURL := &url.URL{
    Scheme: "http",
    Host:   "proxy-host:proxy-port",
    User:   url.UserPassword("username", "password"),
}

Both produce the same result. Pick whichever fits how you're storing credentials.

Using environment variables instead of hardcoding

If you don't set Transport at all, Go's http.DefaultTransport already checks the HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables for you:

resp, err := http.Get("https://example.com")

This picks up a proxy automatically if those variables are set in your shell or your container's environment. It's the same behavior most CLI tools use, so it's a good default for scripts you'll run in different environments without changing code.

If you want that same environment-variable behavior on a custom transport (for example, because you're also setting a timeout), use http.ProxyFromEnvironment explicitly:

client := &http.Client{
    Transport: &http.Transport{
        Proxy: http.ProxyFromEnvironment,
    },
}

Confirming the proxy is actually being used

A client that returns 200 OK isn't proof the proxy is in the request path, it might just be reaching the target site directly if the proxy config is silently ignored.

Hit an IP-echo endpoint with and without the proxy, and compare:

resp, err := client.Get("https://api.ipify.org")

If the returned IP matches your proxy's IP (not your machine's), the proxy is doing its job. If it matches your own connection, something in the transport setup isn't being applied, usually a Transport created after the client, or a client reused from http.DefaultClient instead of your custom one.

Handling the errors you'll actually hit

Three errors show up most often once you're running this against a real proxy:

proxyconnect tcp: dial tcp ...: connect: connection refused The proxy host or port is wrong, or the proxy is down. Check the address before debugging anything else in your code.

407 Proxy Authentication Required Your credentials are missing or wrong. If you're using the userinfo-in-URL approach, double-check the URL was parsed correctly, a password containing @ or : needs to be URL-encoded or it'll break the parse.

Requests that hang and eventually time out Set an explicit timeout so a dead proxy fails fast instead of hanging your program:

client := &http.Client{
    Transport: &http.Transport{
        Proxy: http.ProxyURL(proxyURL),
    },
    Timeout: 10 * time.Second,
}

Without this, a client using a bad proxy can hang far longer than you'd expect, since Go's default transport has no request-level timeout.

Putting it together

For most Go projects, this is enough:

package main

import (
    "log"
    "net/http"
    "net/url"
    "time"
)

func newProxyClient(rawProxyURL, username, password string) (*http.Client, error) {
    proxyURL, err := url.Parse(rawProxyURL)
    if err != nil {
        return nil, err
    }
    proxyURL.User = url.UserPassword(username, password)

    return &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
        Timeout: 10 * time.Second,
    }, nil
}

func main() {
    client, err := newProxyClient("http://proxy-host:proxy-port", "username", "password")
    if err != nil {
        log.Fatal(err)
    }

    resp, err := client.Get("https://example.com")
    if err != nil {
        log.Fatal(err)
    }
    defer resp.Body.Close()
}

One http.Client, built once, reused across every request that needs to go through the proxy. No dependencies beyond the standard library.

If you're testing this against a real proxy pool rather than a single static proxy, keep in mind that providers billing per successfully authenticated IP expect exactly this kind of username/password setup, so the code above should work against most of them without changes beyond the host, port, and credentials.

Just Launched: ProxiesThatWork.com - Simple, Affordable Proxies That Actually Work

ProxiesThatWork — Sat, 16 Aug 2025 02:03:28 +0000

Hey devs! After a long time quietly building in the background, we just launched something you might find useful - proxies that actually work!

TL;DR:

$3/month for 150 proxies (that's $0.02 per IP)
Instant setup with IP auth and credential login
Public compatibility tests every 5 minutes across the top 1,000 websites
No "contact sales" button

Why We Built It

We’ve spent years working on tools, automations, and data projects that rely on proxies. And we always wanted a service that was simple, affordable, and just work when they're supposed to.

So we built it.

ProxiesThatWork.com is our take on what a proxy platform should feel like: easy to set up, affordable enough for side projects, and transparent enough that you don’t need to guess if it’s working.

No overpricing. No steep learning curve. Just clean IPs, tested constantly, and delivered instantly.

Key Features

✅ Transparent Pricing
No guessing what your final invoice will be. All plans are $0.02 per proxy, billed monthly:

🧪 Tested for compatibility

We run live tests every 5 minutes against the top 1,000 websites (Google, Amazon, Reddit, TikTok, etc.) and publish the results on our site.

We test our proxies continuously and expose the results. If they stop working somewhere, you’ll see it.

🚀 Fast, No-Friction Setup

IP authentication built in
Dashboard shows your proxy list instantly
Works with any tool that supports HTTP/HTTPS proxies
It takes under a minute to go from sign-up to getting your proxies.

Who It’s For

If you’ve ever needed proxies for testing scripts, building automations, running crawlers, or even QA, and got burned by “premium” providers, we built this for you.

Not trying to be everything. Just trying to be reliable.

Try It Now

All plans come with a 7-day guarantee, and you can cancel anytime.

👉 Try it here → https://www.proxiesthatwork.com/

If you have feedback or ideas or if you find something broken, we’re all ears!

Thanks for reading! 🙏

Naomi from ProxiesThatWork.com

DEV Community: ProxiesThatWork