STATIC RESIDENTIAL ISP PROXY

长效静态住宅接入手册

固定住宅 ISP IP，在使用周期内保持同一住宅网络身份。先生成并调用固定 IP 分配链接，再使用返回的 HOST、PORT、代理用户名和密码接入程序。

资源固定住宅 ISP IP 认证仅代理账密 流量不限流量 路由无 SESSION / 不轮转

打开固定 IP 分配查看付费套餐

TWO-STAGE ACCESS

分配固定 IP 与使用代理是两个请求

生成分配链接

在控制台选择套餐、国家、协议和数量，只生成 URL，不立即占用资源。

调用分配链接

调用后才会消耗套餐可提数量，并返回固定代理信息。

使用返回代理

将返回的 HOST、PORT、USER、PASSWORD 配置到采集程序。

分配链接不是代理地址

不能把分配 URL 放进 Requests、Scrapy、浏览器或代理客户端。只有调用后返回的固定代理信息才能用于代理请求。

ALLOCATION API

生成并调用固定 IP 分配链接

控制台会根据当前套餐生成带套餐标识的链接。链接本身不会分配资源；执行下面的请求后才开始分配，响应最长可能等待约 5 分钟。

export STATIC_EXTRACT_URL="YOUR_GENERATED_ALLOCATION_URL"

# 该链接用于分配固定 IP，不是代理地址。
# 调用会消耗套餐可提数量，响应最长可能等待约 5 分钟。
curl --fail-with-body --silent --show-error \
  --max-time 330 \
  "$STATIC_EXTRACT_URL"

import os
import requests

# 调用会从套餐中分配固定 IP，不要把此 URL 配置为代理地址。
response = requests.get(
    os.environ["STATIC_EXTRACT_URL"],
    timeout=330,
)
response.raise_for_status()

proxies = []
for raw_line in response.text.splitlines():
    line = raw_line.strip()
    if not line:
        continue
    host, port, username, password = line.split(":", 3)
    proxies.append({
        "host": host,
        "port": int(port),
        "username": username,
        "password": password,
    })

print(proxies)

// Node.js 18+
async function main() {
  // 调用会从套餐中分配固定 IP，不要把此 URL 配置为代理地址。
  const response = await fetch(process.env.STATIC_EXTRACT_URL, {
    signal: AbortSignal.timeout(330000),
  });
  if (!response.ok) {
    throw new Error("HTTP " + response.status + ": " + await response.text());
  }

  const proxies = (await response.text())
    .split(/\r?\n/)
    .map((line) => line.trim())
    .filter(Boolean)
    .map((line) => {
      const [host, port, username, ...passwordParts] = line.split(":");
      return {
        host,
        port: Number(port),
        username,
        password: passwordParts.join(":"),
      };
    });

  console.log(proxies);
}

main().catch((error) => {
  console.error(error);
  process.exitCode = 1;
});

package main

import (
    "bufio"
    "fmt"
    "net/http"
    "os"
    "strconv"
    "strings"
    "time"
)

func main() {
    client := &http.Client{Timeout: 330 * time.Second}
    response, err := client.Get(os.Getenv("STATIC_EXTRACT_URL"))
    if err != nil { panic(err) }
    defer response.Body.Close()
    if response.StatusCode >= 400 { panic(response.Status) }

    scanner := bufio.NewScanner(response.Body)
    for scanner.Scan() {
        parts := strings.SplitN(strings.TrimSpace(scanner.Text()), ":", 4)
        if len(parts) != 4 { panic("无法识别提取结果") }
        port, err := strconv.Atoi(parts[1])
        if err != nil { panic(err) }
        fmt.Printf("host=%s port=%d user=%s password=%s\n",
            parts[0], port, parts[2], parts[3])
    }
    if err := scanner.Err(); err != nil { panic(err) }
}

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 AllocateStaticProxy {
    public static void main(String[] args) throws Exception {
        HttpClient client = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(30))
            .build();
        HttpRequest request = HttpRequest.newBuilder()
            .uri(URI.create(System.getenv("STATIC_EXTRACT_URL")))
            .timeout(Duration.ofSeconds(330))
            .GET()
            .build();
        HttpResponse<String> response = client.send(
            request,
            HttpResponse.BodyHandlers.ofString()
        );
        if (response.statusCode() >= 400) {
            throw new RuntimeException(response.body());
        }
        for (String rawLine : response.body().split("\\R")) {
            String line = rawLine.trim();
            if (line.isEmpty()) continue;
            String[] parts = line.split(":", 4);
            if (parts.length != 4) {
                throw new IllegalArgumentException("无法识别提取结果");
            }
            System.out.printf(
                "host=%s port=%s user=%s password=%s%n",
                parts[0], parts[1], parts[2], parts[3]
            );
        }
    }
}

<?php
// 调用会从套餐中分配固定 IP，不要把此 URL 配置为代理地址。
$curl = curl_init(getenv("STATIC_EXTRACT_URL"));
curl_setopt_array($curl, [
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_CONNECTTIMEOUT => 30,
    CURLOPT_TIMEOUT => 330,
    CURLOPT_FAILONERROR => true,
]);
$body = curl_exec($curl);
if ($body === false) {
    throw new RuntimeException(curl_error($curl));
}
curl_close($curl);

$proxies = [];
foreach (preg_split('/\R/', trim($body)) as $line) {
    if ($line === '') continue;
    $parts = explode(':', $line, 4);
    if (count($parts) !== 4) {
        throw new RuntimeException('无法识别提取结果');
    }
    [$host, $port, $username, $password] = $parts;
    $proxies[] = compact('host', 'port', 'username', 'password');
}
print_r($proxies);

不要自动重试未知结果的分配请求

调用会消耗套餐剩余可提数量。遇到连接中断时，先刷新“已分配固定 IP”列表，确认结果后再决定是否重试。

ALLOCATION RESPONSE

解析每行返回的固定代理

成功响应为纯文本，每行一个固定代理，顺序固定为 HOST:PORT:USER:PASSWORD。密码中如包含冒号，解析时最多只切分前三个冒号。

分配响应示例 203.0.113.24:10001:proxy_user:proxy_password

示例 IP 属于文档保留地址。真实返回结果会同时出现在控制台“已分配固定 IP”列表。

HOST已分配固定代理主机或 IP

PORT该固定代理的接入端口

USER固定代理认证用户名

PASSWORD固定代理认证密码

PROXY REQUEST

使用已分配代理访问目标

把分配响应中的四个字段写入环境变量，再运行下面的标准代理代码。这个请求访问测试目标，不会再次调用分配 API。

export STATIC_PROXY_HOST="控制台返回的固定代理IP"
export STATIC_PROXY_PORT="控制台返回的代理端口"
export PROXY_USER="控制台返回的代理用户名"
export PROXY_PASS="控制台返回的代理密码"

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

import os
import requests

host = os.environ["STATIC_PROXY_HOST"]
port = int(os.environ["STATIC_PROXY_PORT"])
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: process.env.STATIC_PROXY_HOST,
      port: Number(process.env.STATIC_PROXY_PORT),
      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: os.Getenv("STATIC_PROXY_HOST") + ":" + os.Getenv("STATIC_PROXY_PORT"),
        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 = System.getenv("STATIC_PROXY_HOST");
        int port = Integer.parseInt(System.getenv("STATIC_PROXY_PORT"));
        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 = getenv("STATIC_PROXY_HOST");
$port = (int) getenv("STATIC_PROXY_PORT");
$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;

固定代理在使用周期内不轮转

同一代理保持固定住宅 ISP 身份，适合长期账号、区域内容和稳定会话。

AUTHENTICATION BOUNDARY

静态代理只支持账密认证

支持：代理用户名与密码程序通过分配结果中的 USER 和 PASSWORD 连接代理。

不支持：123Proxy 套餐 IP 白名单认证不能仅凭采集服务器公网 IP 连接静态代理。

不支持：SESSION出口本身固定，不需要在认证用户名中加入 SESSION。

不支持：自动轮转需要周期换 IP 时请选择动态住宅或隧道代理。

固定出口可以登记到目标系统白名单

这表示将固定代理出口 IP 加到合作方 API 或企业系统的来源 IP 白名单；连接 123Proxy 代理本身仍必须使用代理账密。

LOCATION INVENTORY

地区在分配时按库存选择

国家范围按住宅 ISP 实时库存分配，最终可选项以控制台为准。页面显示中文地区名称，实际分配前应以控制台当前可选库存为准。

查看长效静态住宅支持的国家和地区69 个

阿联酋阿根廷奥地利澳大利亚孟加拉国比利时保加利亚巴西加拿大瑞士智利哥伦比亚塞浦路斯捷克德国丹麦阿尔及利亚爱沙尼亚埃及西班牙芬兰法国英国格鲁吉亚希腊中国香港洪都拉斯克罗地亚匈牙利印度尼西亚爱尔兰以色列印度意大利日本肯尼亚柬埔寨韩国哈萨克斯坦斯里兰卡立陶宛拉脱维亚摩洛哥马耳他墨西哥马来西亚尼日利亚荷兰挪威新西兰秘鲁菲律宾巴基斯坦波兰葡萄牙罗马尼亚塞尔维亚沙特阿拉伯瑞典新加坡斯洛伐克泰国土耳其中国台湾乌克兰美国委内瑞拉越南南非

RESOURCE LIFECYCLE

管理已分配固定 IP

分配后保存凭证从控制台已分配列表读取，不依赖旧的分配请求响应。

按项目隔离固定出口记录套餐、业务、国家和固定代理之间的映射。

到期前处理续费固定身份任务应提前确认续费和资源状态。

健康异常及时替换记录连接错误、目标响应和固定出口健康状态。

TROUBLESHOOTING

常见问题

为什么分配链接不能配置到代理客户端？

分配链接是用于领取固定 IP 的 API 请求。必须先调用并解析返回的 HOST、PORT、USER、PASSWORD，再使用这些字段连接代理。

静态代理是否支持 IP 白名单认证？

不支持。两类静态代理连接 123Proxy 时都必须使用返回的代理用户名和密码。

重复调用分配链接会发生什么？

每次成功调用都可能继续消耗套餐可提数量。发生超时或断连时先检查已分配列表，不要直接循环重试。

固定住宅 IP 会自动轮转吗？

不会。固定住宅 ISP IP 在使用周期内保持稳定，不支持 SESSION 或自动轮转。

是否提供免费测试？

不提供。两类静态代理需要直接购买付费套餐，再在控制台按库存分配固定 IP。