The practical differences that affect your architecture:

One underappreciated difference: SOCKS5's socks5h:// scheme delegates DNS resolution to the proxy server rather than your machine. This matters for geo-targeting accuracy because local DNS can return a geographically mismatched IP, undermining the entire point of routing through a residential proxy. It's a silent failure mode because the request still succeeds and the IP check still shows the proxy address.

SOCKS5 also supports UDP, though adoption remains narrow. Proxyway found only 3 of 13 residential providers enabled UDP in 2026, with 8 more potentially offering it. Verify UDP availability with your provider before designing any UDP-dependent workflow.

requests supports SOCKS5 through the optional PySocks dependency. Install it with the extras flag:

pip install requests[socks]

Configure a reusable session with your proxy credentials:

import requests

proxies = {
    "http":  "socks5h://username:password@proxy_host:1080",
    "https": "socks5h://username:password@proxy_host:1080",
}

with requests.Session() as session:
    session.proxies = proxies
    response = session.get("https://ipinfo.io/json", timeout=10)
    print(response.json())

The socks5h:// scheme is the critical detail here. The h suffix tells requests to forward the hostname to the proxy server for DNS resolution rather than resolving it on your machine. Use socks5:// only when you intentionally want your ISP’s DNS to resolve the hostname, which is rarely the correct choice for geo-targeted scraping.

Always set an explicit timeout. Without one, a stalled proxy connection will hang the thread indefinitely with no error.

What we’ve found with session management: Attaching the proxy to a Session object cuts connection overhead by roughly 30% compared to passing proxies= to individual requests.get() calls. Session reuse keeps the underlying socket alive between requests to the same host, which adds up at scale.

Verify the proxy is working before running at scale:

response = session.get("https://ipinfo.io/json", timeout=10)
data = response.json()
print(data.get("ip"))       # Should show the proxy's IP
print(data.get("country"))  # Verify geo-location matches your target region

Check both the IP and the country. A passing IP check with the wrong country is the DNS leak symptom described above.

httpx handles both sync and async contexts without requiring separate libraries. Install SOCKS support alongside the package:

pip install httpx[socks]

Synchronous usage:

import httpx

with httpx.Client(

proxy="socks5://username:password@proxy_host:1080",

timeout=10

) as client:

r = client.get("https://ipinfo.io/json")

print(r.json())

Async usage, which is the recommended pattern for high-concurrency scrapers:

import asyncio

import httpx

async def fetch(url: str) -> dict:

async with httpx.AsyncClient(

proxy="socks5://username:password@proxy_host:1080",

timeout=10

) as client:

r = await client.get(url)

return r.json()

result = asyncio.run(fetch("https://ipinfo.io/json"))

print(result)

httpx uses socks5:// and handles remote DNS resolution automatically for proxy schemes. You don't need the h suffix here as you do in requests.

aiohttp doesn't support SOCKS5 natively. Add aiohttp-socks to fill the gap:

pip install aiohttp aiohttp-socks

import asyncio

import aiohttp

from aiohttp_socks import ProxyConnector

async def fetch():

connector = ProxyConnector.from_url(

"socks5://username:password@proxy_host:1080"

)

async with aiohttp.ClientSession(connector=connector) as session:

async with session.get(

"https://ipinfo.io/json",

timeout=aiohttp.ClientTimeout(total=10)

) as response:

return await response.json()

print(asyncio.run(fetch()))

ProxyConnector handles the SOCKS5 handshake for every connection in the session. Create one connector per session, not one per request. Recreating it per request throws away the connection pool and eliminates the performance advantage of using aiohttp in the first place.

Node.js 18+ includes native fetch, but it doesn't accept a custom agent directly. Use node-fetch for agent injection:

npm install node-fetch

import fetch from "node-fetch";

import { SocksProxyAgent } from "socks-proxy-agent";

const agent = new SocksProxyAgent(

"socks5://username:password@proxy_host:1080"

);

const res = await fetch("https://ipinfo.io/json", { agent });

const data = await res.json();

console.log(data.ip);

For TypeScript with environment-variable credentials:

import fetch from "node-fetch";

import { SocksProxyAgent } from "socks-proxy-agent";

const proxyUrl = socks5://${process.env.PROXY_USER}:${process.env.PROXY_PASS}@${process.env.PROXY_HOST}:1080;

const agent = new SocksProxyAgent(proxyUrl);

const res = await fetch("https://ipinfo.io/json", { agent });

const data = (await res.json()) as { ip: string; country: string };

console.log(data);

Store credentials in environment variables. Rotating credentials in .env is far simpler than patching source files across a distributed fleet.

axios needs the agent set on both httpAgent and httpsAgent to cover all traffic types:

const axios = require("axios");

const { SocksProxyAgent } = require("socks-proxy-agent");

const agent = new SocksProxyAgent(

"socks5://username:password@proxy_host:1080"

);

const { data } = await axios.get("https://ipinfo.io/json", {

httpAgent: agent,

httpsAgent: agent,

timeout: 10000,

});

console.log(data.ip);

For repeated requests, create an axios instance with the agent preset so you're not reconstructing it on every call:

const client = axios.create({

httpAgent: agent,

httpsAgent: agent,

timeout: 10000,

});

const { data } = await client.get("https://ipinfo.io/json");

Puppeteer doesn't have a dedicated proxy API. Pass the proxy as a Chromium launch argument using the --proxy-server flag:

const puppeteer = require("puppeteer");

const browser = await puppeteer.launch({

headless: true,

args: [

"--proxy-server=socks5://proxy_host:1080",

"--no-sandbox",

],

});

const page = await browser.newPage();

// Call authenticate() before goto(), not after

await page.authenticate({

username: "username",

password: "password",

});

await page.goto("https://ipinfo.io/json");

console.log(await page.content());

await browser.close();

page.authenticate() must run before page.goto(). Calling it after the navigation starts causes Chromium to ignore the credentials for the initial request.

Per-page proxy rotation: Puppeteer routes all pages in a browser instance through the same proxy. To use a different proxy per page, launch separate browser instances. For production-scale rotation, use puppeteer-cluster with a proxy pool to manage the overhead of multiple instances.

Playwright has first-class proxy support at the browser and context levels, making per-context proxy assignment cleaner than the Puppeteer approach:

const { chromium } = require("playwright");

// Context-level proxy (recommended for rotation)

const browser = await chromium.launch();

const context = await browser.newContext({

proxy: {

server: "socks5://proxy_host:1080",

username: "username",

password: "password",

},

});

const page = await context.newPage();

await page.goto("https://ipinfo.io/json");

console.log(await page.textContent("body"));

await browser.close();

Setting the proxy at the context level lets you run multiple browser contexts in parallel, each routing through a different SOCKS5 endpoint, without spawning separate browser processes. This is the more resource-efficient pattern for large-scale automation.

Python Playwright follows the same structure:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:

browser = p.chromium.launch()

context = browser.new_context(

proxy={

"server": "socks5://proxy_host:1080",

"username": "username",

"password": "password",

}

)

page = context.new_page()

page.goto("https://ipinfo.io/json")

print(page.content())

browser.close()

For non-automated sessions (QA verification, manual geo-testing), configure SOCKS5 through a browser extension:

• FoxyProxy Standard (Chrome, Firefox): supports per-URL proxy rules and SOCKS5
• Proxy SwitchyOmega (Chrome, Edge): profile-based proxy switching with a toolbar toggle

Both accept the standard host/port fields with a username/password credential section. No technical configuration is needed beyond filling in those four fields.

From the Chrome command line (useful in CI environments for quick checks):

google-chrome --proxy-server="socks5://proxy_host:1080" https://ipinfo.io/json