DEV Community: ProxiesThatWork

Proxies in Java: Setting Up HttpClient and OkHttp

ProxiesThatWork — Thu, 17 Sep 2026 13:08:33 +0000

If you need to route Java HTTP requests through a proxy, you have two solid options: the built-in java.net.http.HttpClient (Java 11+, no dependencies), or OkHttp, if you're already using it for other reasons.

Both handle proxies natively. Here's the direct answer for each, starting with the one that needs zero extra dependencies.

Setting a proxy with java.net.http.HttpClient

Since Java 11, the standard library ships its own HTTP client. To send requests through a proxy, give it a ProxySelector pointed at your proxy's host and port:

import java.net.InetSocketAddress;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;

public class ProxyExample {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .proxy(ProxySelector.of(new InetSocketAddress("proxy-host", 8080)))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://example.com"))
            .build();

        HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
        System.out.println(response.body());
    }
}

Every request sent with client now goes through the proxy. No third-party library required.

Adding authentication to HttpClient

Most paid proxies need a username and password. HttpClient doesn't read credentials from a URL, you give it an Authenticator instead:

import java.net.Authenticator;
import java.net.PasswordAuthentication;

HttpClient client = HttpClient.newBuilder()
    .proxy(ProxySelector.of(new InetSocketAddress("proxy-host", 8080)))
    .authenticator(new Authenticator() {
        @Override
        protected PasswordAuthentication getPasswordAuthentication() {
            return new PasswordAuthentication("username", "password".toCharArray());
        }
    })
    .build();

HttpClient calls this automatically when the proxy responds with a 407 Proxy Authentication Required, and retries the request with the credentials attached.

Setting a proxy with OkHttp

If your project already pulls in OkHttp, the setup is just as direct:

import okhttp3.OkHttpClient;
import okhttp3.Request;
import okhttp3.Response;

import java.net.InetSocketAddress;
import java.net.Proxy;

OkHttpClient client = new OkHttpClient.Builder()
    .proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy-host", 8080)))
    .build();

Request request = new Request.Builder()
    .url("https://example.com")
    .build();

try (Response response = client.newCall(request).execute()) {
    System.out.println(response.body().string());
}

Same idea: build a Proxy object, attach it to the client, reuse that client for every call.

Adding authentication to OkHttp

OkHttp uses an Authenticator too, but its own interface, not java.net.Authenticator. This one responds to the 407 challenge and returns a modified request with the auth header attached:

import okhttp3.Credentials;
import okhttp3.Route;

import java.io.IOException;

OkHttpClient client = new OkHttpClient.Builder()
    .proxy(new Proxy(Proxy.Type.HTTP, new InetSocketAddress("proxy-host", 8080)))
    .proxyAuthenticator((Route route, Response response) -> {
        String credential = Credentials.basic("username", "password");
        return response.request().newBuilder()
            .header("Proxy-Authorization", credential)
            .build();
    })
    .build();

Credentials.basic() handles the Base64 encoding for you, you don't need to build the header string by hand.

Confirming the proxy is actually being used

A 200 OK response isn't proof the proxy is in the request path. If the proxy config was silently ignored, you'd still get a successful response, just from your own IP instead of the proxy's.

Hit an IP-echo endpoint with your proxied client and check what comes back:

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://api.ipify.org"))
    .build();

If the returned IP matches your proxy provider's range, it's working. If it matches your own connection's IP, the proxy isn't actually being applied, usually because a request was sent with a plain HttpClient.newHttpClient() instead of the builder you configured.

Handling the errors you'll actually hit

407 Proxy Authentication Required
Your authenticator either isn't attached to the client, or the credentials are wrong. With HttpClient, double-check .authenticator(...) was called on the same builder that made the client you're using, it's easy to configure one client and accidentally send requests with another.

Connection refused / connection timed out
The proxy host or port is wrong, or the proxy is down. Set an explicit timeout so a dead proxy fails fast instead of hanging:

HttpClient client = HttpClient.newBuilder()
    .proxy(ProxySelector.of(new InetSocketAddress("proxy-host", 8080)))
    .connectTimeout(java.time.Duration.ofSeconds(10))
    .build();

OkHttp's builder has the equivalent: .connectTimeout(10, TimeUnit.SECONDS).

ProxySelector.of() silently not applying to HTTPS requests
This one catches people off guard: ProxySelector.of() covers both HTTP and HTTPS targets by default, but if you've built a custom ProxySelector subclass instead, make sure select() returns your proxy for HTTPS URIs too, not just plain HTTP ones. A selector that only handles http:// targets will silently connect directly for every https:// request.

Which one should you use?

If you're not already using OkHttp for something else, HttpClient is the simpler choice, it ships with the JDK, so there's nothing to add to your build file. If your project already depends on OkHttp (common in Android and Spring-adjacent stacks), stick with it rather than running two HTTP clients side by side.

Either way, the pattern is the same: configure the proxy once on the client, reuse that client everywhere, and set a timeout so a bad proxy fails loudly instead of hanging your app. It's the same shape as setting up a proxy client in Go, build the client once with the proxy attached, then reuse it for every request, just expressed through Java's builder pattern instead of a Go struct.

These libraries handle the network connection, not browser fingerprinting or JavaScript rendering. If a target site is blocking on IP reputation rather than bot-detection scripts, a plain datacenter proxy pool is usually enough for either client above, without paying for residential pricing you don't need.

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