不限量动态住宅接入手册

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

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

import os
import requests

host = "unlimit.residential.123proxy.cn"
port = 10253
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: "unlimit.residential.123proxy.cn",
      port: 10253,
      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: "unlimit.residential.123proxy.cn:10253",
        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 = "unlimit.residential.123proxy.cn";
        int port = 10253;
        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 = "unlimit.residential.123proxy.cn";
$port = 10253;
$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;

import os
from concurrent.futures import ThreadPoolExecutor
import requests

host = "unlimit.residential.123proxy.cn"
port = 10253
worker_count = 8
username = os.environ["PROXY_USER"]
password = os.environ["PROXY_PASS"]
target = "https://api.ipify.org?format=json"

def run_worker(worker_id):
    proxy = f"http://{username}:{password}@{host}:{port}"
    response = requests.get(
        target,
        proxies={"http": proxy, "https": proxy},
        timeout=(15, 30),
    )
    response.raise_for_status()
    return worker_id, port, response.json()

with ThreadPoolExecutor(max_workers=worker_count) as pool:
    for worker_id, port, result in pool.map(run_worker, range(worker_count)):
        print(worker_id, port, result)

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

const host = "unlimit.residential.123proxy.cn";
const port = 10253;
const workerCount = 8;
const username = process.env.PROXY_USER;
const password = process.env.PROXY_PASS;

async function runWorker(workerId) {
  const response = await axios.get(
    "https://api.ipify.org?format=json",
    {
      proxy: {
        protocol: "http",
        host,
        port,
        auth: { username, password },
      },
      timeout: 30000,
    },
  );
  console.log({ workerId, port, data: response.data });
}

Promise.all(
  Array.from({ length: workerCount }, (_, workerId) => runWorker(workerId)),
).catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

package main

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

func main() {
    const workerCount = 8
    var wait sync.WaitGroup

    for workerID := 0; workerID < workerCount; workerID++ {
        wait.Add(1)
        go func(id int) {
            defer wait.Done()
            proxyURL := &url.URL{
                Scheme: "http",
                Host: "unlimit.residential.123proxy.cn:10253",
                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()
            body, err := io.ReadAll(response.Body)
            if err != nil { panic(err) }
            if response.StatusCode >= 400 { panic(response.Status) }
            fmt.Printf("worker=%d gateway=unlimit.residential.123proxy.cn:10253 %s\n", id, body)
        }(workerID)
    }
    wait.Wait()
}