proxy code generator

import requests

# the country and the session ride in the username, not in a separate option
PROXY = "http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080"

# the dict key is the scheme of the TARGET url, so both keys point at the same proxy
PROXIES = {"http": PROXY, "https": PROXY}

resp = requests.get("http://api.ipify.org", proxies=PROXIES, timeout=30)
print(resp.text)

import httpx

PROXY = "http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080"

# proxy= is singular. the plural proxies= argument was removed in httpx 0.28.
with httpx.Client(proxy=PROXY, timeout=30.0) as client:
    resp = client.get("http://api.ipify.org")
    print(resp.text)

import asyncio

import aiohttp

PROXY = "http://geo.myxproxy.com:8080"
# aiohttp takes credentials as an object, so nothing has to survive url encoding
AUTH = aiohttp.BasicAuth("u123456", "YOUR_PASSWORD")


async def main():
    async with aiohttp.ClientSession() as session:
        async with session.get("http://api.ipify.org", proxy=PROXY, proxy_auth=AUTH) as resp:
            print(await resp.text())


asyncio.run(main())

from playwright.sync_api import sync_playwright

# credentials go in their own fields. put them in the server url and chromium ignores them.
PROXY = {
    "server": "http://geo.myxproxy.com:8080",
    "username": "u123456",
    "password": "YOUR_PASSWORD",
}

with sync_playwright() as p:
    browser = p.chromium.launch(proxy=PROXY)
    page = browser.new_page()
    page.goto("http://api.ipify.org")
    print(page.inner_text("body"))
    browser.close()

import base64

import scrapy

PROXY = "http://geo.myxproxy.com:8080"
USER = "u123456"
PASSWORD = "YOUR_PASSWORD"

# scrapy 2.6 stopped honouring credentials inside meta["proxy"], so they go in the header.
# the meta key is "proxy"; http_proxy is the environment variable, which is a different thing.
CREDS = base64.b64encode((USER + ":" + PASSWORD).encode()).decode()


class ExitIpSpider(scrapy.Spider):
    name = "exit_ip"

    def start_requests(self):
        yield scrapy.Request(
            "http://api.ipify.org",
            meta={"proxy": PROXY},
            headers={"Proxy-Authorization": "Basic " + CREDS},
        )

    def parse(self, response):
        yield {"exit_ip": response.text}

// npm i undici
// node bundles undici internally to power the global fetch, but does not publish it as a
// module: on node 24 both require("undici") and node:undici fail until the package is
// installed. plain fetch has no proxy option, so ProxyAgent has to come from there.
import { ProxyAgent } from "undici";

const agent = new ProxyAgent("http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080");

const res = await fetch("http://api.ipify.org", { dispatcher: agent });
console.log(await res.text());

// npm i axios
import axios from "axios";

// the proxy object keeps credentials out of a url, so no percent encoding is involved
const res = await axios.get("http://api.ipify.org", {
  proxy: {
    protocol: "http",
    host: "geo.myxproxy.com",
    port: 8080,
    auth: { username: "u123456", password: "YOUR_PASSWORD" },
  },
});
console.log(res.data);

// npm i puppeteer
import puppeteer from "puppeteer";

// the flag carries the endpoint only. credentials in it are ignored by chromium.
const browser = await puppeteer.launch({ args: ["--proxy-server=http://geo.myxproxy.com:8080"] });
const page = await browser.newPage();
await page.authenticate({ username: "u123456", password: "YOUR_PASSWORD" });
await page.goto("http://api.ipify.org", { waitUntil: "domcontentloaded" });
console.log(await page.evaluate(() => document.body.innerText));
await browser.close();

// npm i playwright
import { chromium } from "playwright";

// server carries the endpoint. credentials are separate fields; inside the url they fail silently.
const browser = await chromium.launch({
  proxy: {
    server: "http://geo.myxproxy.com:8080",
    username: "u123456",
    password: "YOUR_PASSWORD",
  },
});
const page = await browser.newPage();
await page.goto("http://api.ipify.org");
console.log(await page.innerText("body"));
await browser.close();

package main

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

func main() {
	// credentials live in the url userinfo, percent encoded
	proxyURL, err := url.Parse("http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080")
	if err != nil {
		panic(err)
	}

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

	resp, err := client.Get("http://api.ipify.org")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(body))
}

package main

import (
	"crypto/tls"
	"fmt"
	"io"
	"net/http"
	"net/url"
	"time"
)

func main() {
	proxyURL, err := url.Parse("http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080")
	if err != nil {
		panic(err)
	}

	transport := &http.Transport{
		Proxy: http.ProxyURL(proxyURL),
		TLSClientConfig: &tls.Config{
			// certificate verification stays on. the proxy relays the tls bytes and never
			// terminates them, so the chain the target presents is the one you verify. turning
			// this off would hide a real interception rather than fix a proxy problem.
			MinVersion: tls.VersionTLS12,
		},
		ForceAttemptHTTP2:   true,
		MaxIdleConns:        100,
		MaxIdleConnsPerHost: 100,
		IdleConnTimeout:     90 * time.Second,
	}

	client := &http.Client{Transport: transport, Timeout: 30 * time.Second}

	resp, err := client.Get("http://api.ipify.org")
	if err != nil {
		panic(err)
	}
	defer resp.Body.Close()

	body, err := io.ReadAll(resp.Body)
	if err != nil {
		panic(err)
	}
	fmt.Println(string(body))
}

// in Cargo.toml: reqwest = { version = "0.12", features = ["blocking"] }

use std::time::Duration;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // basic_auth keeps the password out of the url, so no percent encoding is involved
    let proxy = reqwest::Proxy::all("http://geo.myxproxy.com:8080")?
        .basic_auth("u123456", "YOUR_PASSWORD");

    let client = reqwest::blocking::Client::builder()
        .proxy(proxy)
        .timeout(Duration::from_secs(30))
        .build()?;

    let body = client.get("http://api.ipify.org").send()?.text()?;
    println!("{}", body);

    Ok(())
}

// in Cargo.toml: reqwest = "0.12"
//                tokio = { version = "1", features = ["full"] }

use std::time::Duration;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let proxy = reqwest::Proxy::all("http://geo.myxproxy.com:8080")?
        .basic_auth("u123456", "YOUR_PASSWORD");

    let client = reqwest::Client::builder()
        .proxy(proxy)
        .timeout(Duration::from_secs(30))
        .build()?;

    let body = client.get("http://api.ipify.org").send().await?.text().await?;
    println!("{}", body);

    Ok(())
}

curl -sS -x 'http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080' 'http://api.ipify.org'

# the value is scheme:proxy-url, where the first scheme is the one being proxied
http --proxy='http:http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080' \
     --proxy='https:http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080' \
     'http://api.ipify.org'

# wget ignores userinfo in a proxy url, so the endpoint and the credentials are separate:
# the endpoint comes from the environment, the credentials from flags.
http_proxy='http://geo.myxproxy.com:8080' https_proxy='http://geo.myxproxy.com:8080' \
  wget -e use_proxy=yes \
       --proxy-user='u123456' \
       --proxy-password='YOUR_PASSWORD' \
       -qO - 'http://api.ipify.org'

http://u123456:YOUR_PASSWORD@geo.myxproxy.com:8080