How to Use Proxies in Python and Playwright

pip install "requests[socks]" "httpx[socks]" playwright
playwright install chromium

export PROXY_HOST="gw.2captcha.com"      # Replace with the gateway host from your dashboard
export PROXY_PORT="8080"                 # HTTP/HTTPS or SOCKS5 port from your dashboard
export PROXY_USER="your_proxy_username"  # Includes geo/session flags configured in dashboard
export PROXY_PASS="your_proxy_password"

import os
from urllib.parse import quote_plus
import requests

def build_proxy_url(scheme: str = "http") -> str:
    host = os.environ["PROXY_HOST"]
    port = os.environ["PROXY_PORT"]
    user = quote_plus(os.environ["PROXY_USER"])
    password = quote_plus(os.environ["PROXY_PASS"])
    return f"{scheme}://{user}:{password}@{host}:{port}"

def verify_egress_ip() -> None:
    # Use "http" for standard HTTP/CONNECT tunneling or "socks5h" for remote DNS SOCKS5
    proxy_url = build_proxy_url(scheme="http")
    proxies = {
        "http": proxy_url,
        "https": proxy_url,
    }

    with requests.Session() as session:
        session.proxies.update(proxies)
        response = session.get("https://httpbin.org/ip", timeout=15)
        response.raise_for_status()
        print("Egress IP response:", response.json())

if __name__ == "__main__":
    verify_egress_ip()

import asyncio
import os
from urllib.parse import quote_plus
import httpx

def get_proxy_url() -> str:
    host = os.environ["PROXY_HOST"]
    port = os.environ["PROXY_PORT"]
    user = quote_plus(os.environ["PROXY_USER"])
    password = quote_plus(os.environ["PROXY_PASS"])
    return f"http://{user}:{password}@{host}:{port}"

async def fetch_with_retry(
    client: httpx.AsyncClient,
    url: str,
    semaphore: asyncio.Semaphore,
    max_attempts: int = 3,
) -> dict:
    async with semaphore:
        for attempt in range(1, max_attempts + 1):
            try:
                resp = await client.get(url, timeout=15.0)
                resp.raise_for_status()
                return {"url": url, "status": resp.status_code, "data": resp.json()}
            except (httpx.HTTPError, httpx.TimeoutException) as exc:
                if attempt == max_attempts:
                    return {"url": url, "status": None, "error": str(exc)}
                await asyncio.sleep(1.5 * attempt)

async def main() -> None:
    proxy_url = get_proxy_url()
    semaphore = asyncio.Semaphore(10)  # Cap concurrent connections
    targets = ["https://httpbin.org/ip" for _ in range(5)]

    async with httpx.AsyncClient(proxy=proxy_url, http2=True) as client:
        tasks = [fetch_with_retry(client, url, semaphore) for url in targets]
        results = await asyncio.gather(*tasks)
        for item in results:
            print(item)

if __name__ == "__main__":
    asyncio.run(main())

import asyncio
import os
from playwright.async_api import async_playwright, Route

BLOCKED_RESOURCE_TYPES = {"image", "media", "font"}

async def block_heavy_assets(route: Route) -> None:
    if route.request.resource_type in BLOCKED_RESOURCE_TYPES:
        await route.abort()
    else:
        await route.continue_()

async def run_playwright_with_proxy() -> None:
    proxy_server = f"http://{os.environ['PROXY_HOST']}:{os.environ['PROXY_PORT']}"
    proxy_config = {
        "server": proxy_server,
        "username": os.environ["PROXY_USER"],
        "password": os.environ["PROXY_PASS"],
    }

    async with async_playwright() as p:
        # Launch browser once; pass proxy at the context level for multi-session isolation
        browser = await p.chromium.launch(headless=True)
        context = await browser.new_context(
            proxy=proxy_config,
            viewport={"width": 1366, "height": 768},
        )

        page = await context.new_page()
        # Strip images, video, and web fonts to save per-GB proxy bandwidth
        await page.route("**/*", block_heavy_assets)

        await page.goto("https://httpbin.org/ip", wait_until="domcontentloaded", timeout=30000)
        body_text = await page.inner_text("body")
        print("Playwright Context Egress IP:", body_text.strip())

        await context.close()
        await browser.close()

if __name__ == "__main__":
    asyncio.run(run_playwright_with_proxy())

Related Guides & Provider Comparisons