STATIC DATACENTER PROXY

长效静态代理接入手册

固定数据中心 IP，强调稳定连接、固定来源与长期任务。先生成并调用固定 IP 分配链接，再使用返回的 HOST、PORT、代理用户名和密码接入程序。

资源固定数据中心 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;

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

同一代理保持固定数据中心出口，适合来源 IP 登记、环境隔离和长期连接。

AUTHENTICATION BOUNDARY

静态代理只支持账密认证

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

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

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

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

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

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

LOCATION INVENTORY

地区在分配时按库存选择

从支持清单选择国家或地区；长效静态代理不支持中国地区 IP。页面显示中文地区名称，实际分配前应以控制台当前可选库存为准。

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

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

不支持中国地区 IP

长效静态代理的支持清单不包含中国。请勿通过手工参数构造不存在的地区。

RESOURCE LIFECYCLE

管理已分配固定 IP

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

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

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

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

TROUBLESHOOTING

常见问题

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

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

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

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

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

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

长效静态代理支持中国地区吗？

不支持。当前数据中心静态代理支持清单不包含中国，实际地区以控制台库存为准。

是否提供免费测试？

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