隧道住宅代理接入手册

export PROXY_USER="YOUR_PROXY_USER"
export PROXY_PASS="YOUR_PROXY_PASSWORD"

curl --fail-with-body --silent --show-error \
  --proxy "http://residential.123proxy.cn:33000" \
  --proxy-user "${PROXY_USER}:${PROXY_PASS}" \
  --connect-timeout 15 \
  --max-time 30 \
  "https://api.ipify.org?format=json"

import os
import requests

host = "residential.123proxy.cn"
port = 33000
username = os.environ["PROXY_USER"]
password = os.environ["PROXY_PASS"]

proxy_url = f"http://{username}:{password}@{host}:{port}"
proxies = {"http": proxy_url, "https": proxy_url}

response = requests.get(
    "https://api.ipify.org?format=json",
    proxies=proxies,
    timeout=(15, 30),
)
response.raise_for_status()
print(response.json())

// npm install axios
const axios = require("axios");

const response = await axios.get(
  "https://api.ipify.org?format=json",
  {
    proxy: {
      protocol: "http",
      host: "residential.123proxy.cn",
      port: 33000,
      auth: {
        username: process.env.PROXY_USER,
        password: process.env.PROXY_PASS,
      },
    },
    timeout: 30000,
  },
);

console.log(response.data);

package main

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

func main() {
    proxyURL := &url.URL{
        Scheme: "http",
        Host: "residential.123proxy.cn:33000",
        User: url.UserPassword(os.Getenv("PROXY_USER"), os.Getenv("PROXY_PASS")),
    }
    client := &http.Client{
        Transport: &http.Transport{Proxy: http.ProxyURL(proxyURL)},
        Timeout: 30 * time.Second,
    }
    response, err := client.Get("https://api.ipify.org?format=json")
    if err != nil { panic(err) }
    defer response.Body.Close()
    if response.StatusCode >= 400 { panic(response.Status) }
    body, err := io.ReadAll(response.Body)
    if err != nil { panic(err) }
    fmt.Println(string(body))
}

import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.ProxySelector;
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class ProxyCheck {
    public static void main(String[] args) throws Exception {
        System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
        String host = "residential.123proxy.cn";
        int port = 33000;
        String user = System.getenv("PROXY_USER");
        char[] password = System.getenv("PROXY_PASS").toCharArray();

        HttpClient client = HttpClient.newBuilder()
            .proxy(ProxySelector.of(new InetSocketAddress(host, port)))
            .authenticator(new Authenticator() {
                protected PasswordAuthentication getPasswordAuthentication() {
                    return new PasswordAuthentication(user, password);
                }
            })
            .connectTimeout(Duration.ofSeconds(15))
            .build();

        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create("https://api.ipify.org?format=json"))
            .timeout(Duration.ofSeconds(30))
            .GET()
            .build();
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        if (response.statusCode() >= 400) throw new RuntimeException(response.body());
        System.out.println(response.body());
    }
}

<?php
$host = "residential.123proxy.cn";
$port = 33000;
$user = getenv("PROXY_USER");
$password = getenv("PROXY_PASS");

$curl = curl_init("https://api.ipify.org?format=json");
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_PROXY => $host,
    CURLOPT_PROXYPORT => (int) $port,
    CURLOPT_PROXYUSERPWD => $user . ":" . $password,
    CURLOPT_CONNECTTIMEOUT => 15,
    CURLOPT_TIMEOUT => 30,
]);
$body = curl_exec($curl);
if ($body === false) {
    throw new RuntimeException(curl_error($curl));
}
$status = curl_getinfo($curl, CURLINFO_RESPONSE_CODE);
curl_close($curl);
if ($status >= 400) throw new RuntimeException($body);
echo $body . PHP_EOL;