How to Use an HTTPX Proxy: Routing, Auth, and Error Checks

import os
from urllib.parse import quote
import httpx
host = os.environ["APP_PROXY_HOST"]
port = os.environ["APP_PROXY_PORT"]
user = quote(os.environ["APP_PROXY_USER"], safe="")
password = quote(os.environ["APP_PROXY_PASSWORD"], safe="")
check_url = os.environ["AUTHORIZED_IP_CHECK_URL"]
proxy_url = f"http://{user}:{password}@{host}:{port}"
timeout = httpx.Timeout(20.0, connect=6.0)
with httpx.Client(
proxy=proxy_url,
timeout=timeout,
trust_env=False,
) as client:
response = client.get(check_url)
response.raise_for_status()
print(response.text)

URL-encoding the username and password prevents reserved characters from breaking the URL structure. It does not make the value safe to log. Keep the assembled URL in memory and redact it from exceptions and telemetry.

Pattern B: route by request scheme

Use mounts only when HTTP and HTTPS destinations intentionally require different transports. HTTPX documentation notes a common point of confusion: the proxy URL for an

https://

http://

mounts = {
"http://": httpx.HTTPTransport(proxy=proxy_url),
"https://": httpx.HTTPTransport(proxy=proxy_url),
}

with httpx.Client(mounts=mounts, trust_env=False) as client:
response = client.get(check_url)
response.raise_for_status()

Do not change the proxy URL scheme merely because the destination uses HTTPS. Use the scheme specified for the assigned endpoint.

Pattern C: let the environment own routing

HTTPX trusts environment variables by default.

HTTP_PROXY

HTTPS_PROXY

ALL_PROXY

NO_PROXY

This pattern is suitable for a controlled deployment where operations owns the environment. It is less suitable for a self-contained test because the source code no longer shows the effective path. Record the effective variables securely before comparing results, and never print values that contain credentials.

Add async code only after the route works

The routing concepts are the same for

AsyncClient

import asyncio
import httpx

async def verify_async_route() -> None:
async with httpx.AsyncClient(
proxy=proxy_url,
timeout=httpx.Timeout(20.0, connect=6.0),
trust_env=False,
) as client:
response = await client.get(check_url)
response.raise_for_status()
print(response.text)
asyncio.run(verify_async_route())

An async client should be reused for a related batch rather than created for every URL. Keep concurrency conservative and within the target site's rules.

Turn errors into routing evidence

HTTPX exception types help identify the failing layer:

• ProxyError

  points to negotiation with the configured proxy.

• ConnectError

  means HTTPX could not establish a connection, but it does not by itself prove that proxy negotiation was the cause.

• ConnectTimeout

  means the connection stage exceeded the limit.

• ReadTimeout

  means the connection existed but the response did not arrive within the read window.

• HTTPStatusError

  appears after

  raise_for_status()

  for a non-success response.

try:
with httpx.Client(proxy=proxy_url, timeout=timeout, trust_env=False) as client:
response = client.get(check_url)
response.raise_for_status()
except httpx.ProxyError:
print("Proxy negotiation failed")
except httpx.ConnectError:
print("Connection failed")
except httpx.ConnectTimeout:
print("Connection timed out")
except httpx.ReadTimeout:
print("Response timed out")
except httpx.HTTPStatusError as exc:
print("Unexpected HTTP status", exc.response.status_code)

Log the exception class, sanitized host label, target class, and timestamp. Do not log the full proxy URL, authorization data, response cookies, or page content unless there is an approved retention reason.

Verification checklist

1. Confirm the expected host, port, and endpoint scheme from the assignment record.
2. Run one direct baseline only if policy allows it, then one proxied request.
3. Compare the observed address and response status with the expected route.
4. Check that

   NO_PROXY

   did not bypass the diagnostic host.
5. Close the client and remove temporary environment variables.
6. Repeat only when the first result is explainable.

Product boundary

This tutorial covers HTTPX configuration, not product availability. IPIPD currently identifies static IP and VPS as separate product categories; VPS is a server product rather than a proxy type. Use only the current endpoint documentation supplied for your order. Do not infer protocol support, residential or ISP classification, speed, access, or account outcomes from an HTTPX example.

Quick reference: how to choose and verify one HTTPX routing mode

For the field definitions, read the proxy host, port, and authentication guide. For a related Python client pattern, compare the curl route verification guide. Confirm syntax against the official HTTPX proxy documentation.

FAQ