您知道如何使用 PrivateProxy.me API？这是 PrivateProxy.me 官方最全面的介绍。
基本信息
软件包必须处于激活状态，API 才能工作。
您的 API 密钥： 08c5fa8dd63c8adc4b08803df5f68f9d
API 基本 URL： https://app.privateproxy.me/api/v1
授权是标准的基本 auth，api 为用户名，api key 为密码，也可以使用 key 查询参数。
curl -u api:08c5fa8dd63c8adc4b08803df5f68f9d https://app.privateproxy.me/api/v1/package_subscriptions/1/... curl https://app.privateproxy.me/api/v1/package_subscriptions/1/...?key=08c5fa8dd63c8adc4b08803df5f68f9d
API 请求中不能使用非活动订阅。
所有其他示例都使用基本授权。
所有示例的通用代码
Python 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
# 文件名 proxy_api.py
导入 json
导入请求
导入 pprint
类 ProxyAPIException(Exception)：
通过
class RequestError(ProxyAPIException)：
通过
class ResponseError(ProxyAPIException)：
通过
class ResponseParseError(ProxyAPIException): 通过
通过
类 ProxyAPI：
def __init__(self, base, api_key)：
if base.endswith('/')：
self.base = base
else：
self.base = base + '/'
self.api_key = api_key
def __is_json_response(self, response)：
if 'Content-Type' not in response.headers：
返回 False
for part in response.headers['Content-Type'].split(';')：
if part == "application/json"：
返回 True
返回 False
def __process_response(self, response)：
if response.status_code == 200：
error = None
if self.__is_json_response(response)：
try：
obj = json.loads(response.text)
except Exception as e：
error = e
if error：
raise ResponseParseError("Error parsing JSON response from the server：%s" % str(error))
返回 obj
else：
return response.text
else：
if self.__is_json_response(response)：
failed = False
try：
error_json = json.loads(response.text)
except Exception as e：
failed = True
if failed：
raise ResponseError("Received non-200 code from the server, but failed to parse json response：%s" % response.text)
否则
raise ResponseError("Received error from server: %s" % error_json['error'])
else：
raise ResponseError("从服务器收到非 200 代码")
def get(self, endpoint, query_params = {})：
if endpoint[0] == '/'：
endpoint = endpoint[1:]
fin_url = self.base + endpoint
error = None
try：
response = requests.get(fin_url, auth=('api', self.api_key), params = query_params)
except requests.exceptions.RequestException as e：
error = e
if error：
raise RequestError("An error occurred while making a request: %s" % str(error))
return self.__process_response(response)
def put(self, endpoint, body = {})：
if endpoint[0] == '/'：
endpoint = endpoint[1:]
fin_url = self.base + endpoint
error = None
try：
response = requests.put(
fin_url、
auth=('api', self.api_key)、
data = json.dumps(body)、
headers = {'Content-Type': 'application/json'} )
)
except requests.exceptions.RequestException as e：
error = e
if error：
raise RequestError("An error occurred while making a request: %s" % str(error))
return self.__process_response(response)<?php
// filename proxy_api.php
class ProxyAPIException extends Exception {}
class RequestError extends ProxyAPIException {}
class ResponseError extends ProxyAPIException {}
class ResponseParseError extends ProxyAPIException {}
class ProxyAPI {
private $api_base, $api_key;
public function __construct($api_base, $api_key) {
$this->api_base = preg_replace("/\/+$/", "", $api_base);
$this->api_key = $api_key;
}
public function get($endpoint, $query_params = null) {
$endpoint = "/".preg_replace("/^\/+/", "", $endpoint);
$url = $this->api_base.$endpoint;
$query_string = "";
if ($query_params !== null) {
$q = null;
if (is_string($query_params)) {
$q = explode($url, '&');
} elseif (is_array($query_params)) {
$q = $query_params;
}
$tmp = [];
foreach ($q as $key => $value) {
$tmp[] = urlencode($key) . "=" . urlencode($value);
}
$query_string = implode("&", $tmp);
}
if ($query_string !== "") {
$url .= "?".$query_string;
}
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_HTTPAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_USERNAME, "api");
curl_setopt($ch, CURLOPT_PASSWORD, $this->api_key);
$response = curl_exec($ch);
return $this->process_response($ch, $response);
}
public function put($endpoint, $body = null) {
$endpoint = "/" . preg_replace("/^\/+/", "", $endpoint);
$url = $this->api_base . $endpoint;
$data_json = json_encode($body);
if (json_last_error()) {
throw new RequestError("Error encoding body as json: ".json_last_error_msg());
}
$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_USERNAME, "api");
curl_setopt($ch, CURLOPT_PASSWORD, $this->api_key);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "PUT");
curl_setopt($ch, CURLOPT_HTTPHEADER, ["Content-Type:application/json", "Content-Length:".strlen($data_json)]);
curl_setopt($ch, CURLOPT_POSTFIELDS, $data_json);
$response = curl_exec($ch);
return $this->process_response($ch, $response);
}
private function process_response($ch, $response) {
if (curl_error($ch)) {
throw new RequestError("Received error during request: ".curl_error($ch));
}
$response_code = curl_getinfo($ch, CURLINFO_RESPONSE_CODE);
$content_type = curl_getinfo($ch, CURLINFO_CONTENT_TYPE);
$is_json = strstr($content_type, 'application/json') !== false;
curl_close($ch);
if ($response_code == '200') {
if ($is_json) {
$res = json_decode($response, true, 512);
$le = json_last_error();
if ($le != JSON_ERROR_NONE) {
throw new ResponseParseError("Error parsing response from server as JSON: ".json_last_error_msg());
}
return $res;
} else {
return $response;
}
} else {
if ($is_json) {
$res = json_decode($response, true, 512);
$le = json_last_error();
if ($le != JSON_ERROR_NONE) {
throw new ResponseError("Received ".$response_code." code from server, but failed to parse JSON response: ".json_last_error_msg());
}
throw new ResponseError("Received ".$response_code." code from server: ".$res['error']);
} else {
throw new ResponseError("Received ".$response_code." code from server: ".$response);
}
}
}
}// filename proxy_api.js
const https = require('https')
const http = require('http')
const querystring = require('querystring');
function process_response(response, body, resolve, reject) {
const ct = response.headers['content-type'] || '';
let isJson = false;
if (ct.includes("application/json")) {
isJson = true;
}
if (response.statusCode == 200) {
if (isJson) {
let json;
try {
json = JSON.parse(body);
} catch(e) {
reject(e);
return;
}
resolve(json);
} else {
resolve(body);
}
} else {
const err = "Received status " + response.statusCode + " from server";
if (isJson) {
let json;
try {
json = JSON.parse(body);
} catch(e) {
reject(new Error(err + ", but failed to parse JSON: " + body));
return;
}
reject(new Error(err + ": " + json['error']));
} else {
reject(new Error(err + ": " + body));
}
}
}
async function get(url, api_key, query_params = {}) {
const qs = querystring.stringify(query_params);
let final_url = url;
if (qs != '') {
final_url += '?' + qs;
}
const options = {
method: 'GET',
auth: "api:" + api_key
}
const result = await new Promise((resolve, reject) => {
let t;
if (final_url.startsWith("http://")) {
t = http;
} else if (final_url.startsWith("https://")) {
t = https;
}
const req = t.request(final_url, options, (res) => {
res.setEncoding('utf8');
const chunks = [];
res.on('data', (chunk) => {
chunks.push(chunk);
});
res.on('end', () => {
const body = chunks.join('');
process_response(res, body, resolve, reject);
});
});
req.on('error', (e) => {
reject(e);
});
req.end();
}).catch((e) => (e));
return result;
}
async function put(url, api_key, request_body = {}) {
const request_body_str = JSON.stringify(request_body);
const options = {
method: 'PUT',
auth: "api:" + api_key,
headers: {
'Content-Type': 'application/json',
'Content-Length': request_body_str.length
}
}
const result = await new Promise((resolve, reject) => {
let t;
if (url.startsWith("http://")) {
t = http;
} else if (url.startsWith("https://")) {
t = https;
}
const req = t.request(url, options, (res) => {
res.setEncoding('utf8');
const ct = res.headers['content-type'] || '';
let isJson = false;
if (ct.includes("application/json")) {
isJson = true;
}
const chunks = []
res.on('data', (chunk) => {
chunks.push(chunk);
});
res.on('end', () => {
const body = chunks.join('');
process_response(res, body, resolve, reject);
});
});
req.on('error', (e) => {
reject(e);
});
req.write(request_body_str);
req.end();
}).catch((e) => (e));
return result;
}
module.exports = {
get: get,
put: put
}# 文件名 proxy_api.rb
require 'net/http
需要 'uri
需要 'json
类 ProxyAPIException < StandardError
结束
class RequestError < ProxyAPIException
结束
类 ResponseError < 代理 APIException
attr_accessor :code
结束
类 ResponseParseError e
err = RequestError.new(e.message)
结束
raise err if err
return process_response(response)
结束
def put(endpoint, body = {})
endpoint = endpoint.gsub(/^\/+/, '/')
if endpoint[0] != '/'
endpoint = '/' + endpoint
结束
final_url = @base_url + endpoint
uri = URI.parse(final_url)
request = Net::HTTP::Put.new(uri)
req_options = {
use_ssl: uri.scheme == "https"、
}
request.basic_auth('api', @api_key)
request['Content-Type'] = "application/json
request.body = body.to_json
响应 = nil
err = nil
开始
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
response = http.request(request)
结束
救援 => e
err = RequestError.new(e.message)
结束
raise err if err
return process_response(response)
结束
私有
def process_response(response)
如果 response.code == '200'
err = nil
res = begin
if is_json_response?(response)
则 JSON.parse（response.body）
否则
响应正文
结束
救援 => e
err = ResponseParseError.new(e.message)
结束
如果出现 err，则引发 err
返回 res
否则
if is_json_response?(response)
b = JSON.parse(response.body) 返回 nil
如果 b
ex = ResponseError.new("Received code #{response.code} from server: #{b['error']}")
ex.code = response.code.to_i
引发 ex
否则
ex = ResponseError.new("Received code #{response.code} from server, but failed to parse JSON: #{response.body}")
ex.code = response.code.to_i
引发 ex
结束
否则
ex = ResponseError.new("Received code #{response.code} from server: #{response.body}")
ex.code = response.code.to_i
引发 ex
结束
结束
结束
def is_json_response?(response)
response['Content-Type'].to_s.split(';').each do |part|
如果 part == 'application/json' 则返回 true
结束
返回 false
结束
结束# 文件名 proxy_api.rb
require 'net/http
需要 'uri
需要 'json
类 ProxyAPIException < StandardError
结束
class RequestError < ProxyAPIException
结束
类 ResponseError < 代理 APIException
attr_accessor :code
结束
类 ResponseParseError e
err = RequestError.new(e.message)
结束
raise err if err
return process_response(response)
结束
def put(endpoint, body = {})
endpoint = endpoint.gsub(/^\/+/, '/')
if endpoint[0] != '/'
endpoint = '/' + endpoint
结束
final_url = @base_url + endpoint
uri = URI.parse(final_url)
request = Net::HTTP::Put.new(uri)
req_options = {
use_ssl: uri.scheme == "https"、
}
request.basic_auth('api', @api_key)
request['Content-Type'] = "application/json
request.body = body.to_json
响应 = nil
err = nil
开始
response = Net::HTTP.start(uri.hostname, uri.port, req_options) do |http|
response = http.request(request)
结束
救援 => e
err = RequestError.new(e.message)
结束
raise err if err
return process_response(response)
结束
私有
def process_response(response)
如果 response.code == '200'
err = nil
res = begin
if is_json_response?(response)
则 JSON.parse（response.body）
否则
响应正文
结束
救援 => e
err = ResponseParseError.new(e.message)
结束
如果出现 err，则引发 err
返回 res
否则
if is_json_response?(response)
b = JSON.parse(response.body) 返回 nil
如果 b
ex = ResponseError.new("Received code #{response.code} from server: #{b['error']}")
ex.code = response.code.to_i
引发 ex
否则
ex = ResponseError.new("Received code #{response.code} from server, but failed to parse JSON: #{response.body}")
ex.code = response.code.to_i
引发 ex
结束
否则
ex = ResponseError.new("Received code #{response.code} from server: #{response.body}")
ex.code = response.code.to_i
引发 ex
结束
结束
结束
def is_json_response?(response)
response['Content-Type'].to_s.split(';').each do |part|
如果 part == 'application/json' 则返回 true
结束
返回 false
结束
结束获取订阅列表
该端点允许获取所有订阅的列表。
| 终点 | /package_subscriptions |
| 方法 | 获取 |
| 参数 | 无 |
| 查询参数 | 无 |
| JSON 参数 | 无 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -u api:08c5fa8dd63c8adc4b08803df5f68f9d https://app.privateproxy.me/api/v1/package_subscriptions
答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.get("/package_subscriptions")
pprint.PrettyPrinter(indent=2).pprint(result)
except ProxyAPIException as e：
print(str(e))答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]get("/package_subscriptions"))；
} catch(ProxyAPIException $e) {
echo $e；
}答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.get('https://app.privateproxy.me/api/v1/package_subscriptions', '08c5fa8dd63c8adc4b08803df5f68f9d')；
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.get("/package_subscriptions").inspect)
rescue ProxyAPIException => e
puts e.message
结束答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]主包
导入 (
"编码/json"
"fmt"
"net/http"
)
类型 subscriptionEl struct {
ID int `json: "id"`
类型字符串 `json: "type"`
Package string `json: "package"`
活动 bool `json: "active"`
}
类型 subscriptionsList []*subscriptionEl
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
resp, isJSON, err := api.Get("/package_subscriptions", nil)
if err != nil {
fmt.Println(err)
} else {
if isJSON {
var subscriptions subscriptionsList
json.Unmarshal([]byte(resp), &subscriptions)
for _, v := range subscriptions {
fmt.Println(v)
}
} else {
fmt.Println(resp)
}
}
}答复示例：
[
{
"id":8644、
"类型": "Backconnect"、
"包": "Backconnect 入门 (200K 请求)"、
"活动":false
},
{
"id":8643、
"类型": "代理"、
"package": "3 Private Proxies"、
"活动":true
}
]获取订阅
通过该端点，您可以获取特定的订购信息，如计费周期的开始和结束日期，或当前计费周期内 backconnect 套餐的请求数。
| 终点 | /package_subscriptions/:id |
| 方法 | 获取 |
| 参数 | id - 订阅的 id |
| 查询参数 | 无 |
| JSON 参数 | 无 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -u api:08c5fa8dd63c8adc4b08803df5f68f9d https://app.privateproxy.me/api/v1/package_subscriptions/1
答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.get("/package_subscriptions/1")
pprint.PrettyPrinter(indent=2).pprint(result)
except ProxyAPIException as e：
print(str(e))答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
get("/package_subscriptions/1"))；
} catch(ProxyAPIException $e) {
echo $e；
}答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.get('https://app.privateproxy.me/api/v1/package_subscriptions/1', '08c5fa8dd63c8adc4b08803df5f68f9d')；
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.get("/package_subscriptions/1").inspect)
rescue ProxyAPIException => e
puts e.message
结束答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
主包
导入 (
"编码/json"
"fmt"
"net/http"
)
类型 订阅 结构 {
ID int `json: "id"`
类型字符串 `json: "type"`
目的字符串 `json: "purpose"`
国家字符串 `json: "country"`
IPType string `json: "IP_type"`
包装字符串 `json: "package"`
PriceCents int `json: "price_cents"`
BillingCycleStart uint64 `json: "billing_cycle_start"`
BillingCycleEnd uint64 `json: "billing_cycle_end"`
LastInvoiceAmountCents int `json: "last_invoice_amount_cents"`
付款方式字符串 `json: "payment_method"`
// 仅代理
IPCount int `json: "IP_count"`
// 仅反向连接
RequestsLimit int `json: "requests_limit"`
PortCount int `json: "port_count"`
ConnectionLimit int `json: "connection_limit"`
BillingCycleRequests int `json: "billing_cycle_requests"`
}
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
resp, isJSON, err := api.Get("/package_subscriptions/1", nil)
if err != nil {
fmt.Println(err)
} else {
if isJSON {
子订阅
json.Unmarshal([]byte(resp), &sub)
fmt.Println(sub)
} else {
fmt.Println(resp)
}
}
}答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"id":8643、
"类型": "代理
"目的": "谷歌"、
"国家": "任何国家
"ip_type": "proxy"、
包": "3 个私人代理"、
"price_cents":900、
"billing_cycle_start":1599563902,
"billing_cycle_end":1602155902,
"last_invoice_amount_cents":900、
"付款方式": "卡"、
"IP_count":3
}
|
{
"id":8644、
"类型": "backconnect"、
"目的": "谷歌"、
"country": "Any"、
"ip_type": "proxy"、
"软件包": "Backconnect 初级（20 万次请求）"、
"price_cents":5900、
"billing_cycle_start":1599563939,
"billing_cycle_end":1602155939,
"last_invoice_amount_cents":5900、
"付款方式": "卡"、
"requests_limit":200000,
"port_count":5、
"connection_limit":1000,
"billing_cycle_requests":15749
}
|
IP/Port 列表
该端点允许获取软件包的代理/后连接网关 IP 列表。
| 终点 | /package_subscriptions/:id/ips |
| 方法 | 获取 |
| 参数 | id - 订阅的 id |
| 查询参数 | hide_auth - 如果存在，从列表中隐藏证书 hide_port - 隐藏端口（仅限静态软件包） 端口 - 显示不同的端口，可用值为 2534、3389、5432 和 5433，默认值为 5432（仅限静态软件包） |
| JSON 参数 | 无 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -u api:08c5fa8dd63c8adc4b08803df5f68f9d https://app.privateproxy.me/api/v1/package_subscriptions/1/ips
答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.get("/package_subscriptions/1/ips")
pprint.PrettyPrinter(indent=2).pprint(result)
result = api.get("/package_subscriptions/1/ips", query_params={'hide_auth': ''})
pprint.PrettyPrinter(indent=2).pprint(result)
except ProxyAPIException as e：
print(str(e))答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
get("/package_subscriptions/1/ips"))；
var_dump($api->get("/package_subscriptions/1/ips", [
"hide_auth" => ""
]));
} catch(ProxyAPIException $e) {
echo $e；
}答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.get('https://app.privateproxy.me/api/v1/package_subscriptions/1/ips', '08c5fa8dd63c8adc4b08803df5f68f9d')；
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
const res2 = await proxy_api.get('https://app.privateproxy.me/api/v1/package_subscriptions/1/ips', '08c5fa8dd63c8adc4b08803df5f68f9d', {
"hide_auth"：""
});
if (res2 instanceof Error) {
console.log("Error:")+ res2.toString())；
} else {
console.log(res2)；
}
}
main()；答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.get("/package_subscriptions/1/ips").inspect)
puts(api.get("/package_subscriptions/1/ips", hide_auth: '').inspect)
rescue ProxyAPIException => e
puts e.message
结束答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
主包
导入 (
"fmt"
"net/http"
)
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
resp, _, err := api.Get("/package_subscriptions/1/ips", nil)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
resp，_，err = api.Get("/package_subscriptions/1/ips"，map[string]string{"hide_auth": ""})
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
}答复示例：
| 无 hide_auth | 使用 hide_auth |
|---|---|
1.1.1.1:5432:login:password 2.2.2.2:5432:login:password 3.3.3.3:5432:login:password |
1.1.1.1:5432 2.2.2.2:5432 3.3.3.3:5432 |
获取订阅设置
该端点允许获取软件包的特定设置，如授权 ips 和交换间隔（用于 backconnect）。
| 终点 | /package_subscriptions/:id/settings |
| 方法 | 获取 |
| 参数 | id - 订阅的 id |
| 查询参数 | 无 |
| JSON 参数 | 无 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -u api:08c5fa8dd63c8adc4b08803df5f68f9d https://app.privateproxy.me/api/v1/package_subscriptions/1/settings
答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.get("/package_subscriptions/1/settings")
pprint.PrettyPrinter(indent=2).pprint(result)
except ProxyAPIException as e：
print(str(e))答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
get("/package_subscriptions/1/settings"))；
} catch(ProxyAPIException $e) {
echo $e；
}答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.get('https://app.privateproxy.me/api/v1/package_subscriptions/1/settings', '08c5fa8dd63c8adc4b08803df5f68f9d')；
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.get("/package_subscriptions/1/settings").inspect)
rescue ProxyAPIException => e
puts e.message
结束答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
主包
导入 (
"编码/json"
"fmt"
"net/http"
)
类型 packageSettings struct {
授权 IPs []string `json: "authorized_ips"`
//仅回连
交换间隔 int `json: "swap_interval"`
}
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
resp, _, err := api.Get("/package_subscriptions/1/settings", nil)
if err != nil {
fmt.Println(err)
} else {
var ps packageSettings
json.Unmarshal([]byte(resp), &ps)
fmt.Println(ps)
}
}答复示例：
| 代理订阅 | 订阅 Backconnect |
|---|---|
{
"authorized_ips":[
"15.25.5.11"
]
}
|
{
"authorized_ips":[
"15.25.5.11",
"1.1.1.1"
],
"swap_interval":120
}
|
设置订阅设置
该端点允许设置软件包的特定设置，如授权 ips 或交换间隔（用于 backconnect）。
| 终点 | /package_subscriptions/:id |
| 方法 | 输入 |
| 必要的 HTTP 标头 | Content-Type: 应用程序/json |
| 参数 | id - 订阅的 id |
| 查询参数 | 无 |
| JSON 参数 | authorized_ips - 列表 - 允许无凭证访问代理的授权 IP 地址 swap_interval - 整数 >= 0 - 为反向连接代理更换 IP 的频率，0 表示每次请求都更换。普通代理软件包忽略不计。 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -X PUT -H "Content-Type: application/json" -u api:08c5fa8dd63c8adc4b08803df5f68f9d --data '{"swap_interval"：180, "authorized_ips":["1.1.1.1"]}' https://app.privateproxy.me/api/v1/package_subscriptions/1成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.put("/package_subscriptions/1", body = {'swap_interval': 180, 'authorized_ips'：['1.2.3.4', '2.5.6.7']})
print(result)
result = api.put("/package_subscriptions/1", body = {'swap_interval': -180, 'authorized_ips'：['441.2.3.4']})
print(result)
except ProxyAPIException as e：
print(str(e))成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}put("/package_subscriptions/1", [
"authorized_ips" => ["1.5.4.4", "1.5.6.7"]、
"swap_interval" => 3600
]));
var_dump($api->put("/package_subscriptions/1", [
"authorized_ips" => ["1.5.4.444", "1.5.6.7"]、
"swap_interval" => -3600
]));
} catch(ProxyAPIException $e) {
echo $e；
}成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.put(
'https://app.privateproxy.me/api/v1/package_subscriptions/1'、
'08c5fa8dd63c8adc4b08803df5f68f9d',
{
"authorized_ips"：["77.66.55.44", "1.87.31.3"],
"swap_interval"：1200
}
);
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.put("/package_subscriptions/1", authorized_ips: ['1.2.3.2'], swap_interval: 30).inspect)
puts(api.put("/package_subscriptions/1", authorized_ips：[412.2.3.2'], swap_interval: -30).inspect)
rescue ProxyAPIException => e
puts e.message
结束成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}主包
导入 (
"fmt"
"net/http"
"字符串
)
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
ips := strings.Join([]string{"1.2.3.1", "1.3.1.2", "1.1.1.1"}, "\",\"")
settings := fmt.Sprintf("{\"authorized_ips\": [\"%s\"], \"swap_interval\": 4242}", ips)
resp, _, err := api.Put("/package_subscriptions/1", settings)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
ips = strings.Join([]string{"1.2.3.1", "1.3.1.2", "1.1.1.1000"}, "\",\"")
settings = fmt.Sprintf("{\"authorized_ips\": [\"%s\"], \"swap_interval\": -4242}", ips)
resp, _, err = api.Put("/package_subscriptions/1", settings)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
}成功时 {"success":true}将返回 JSON 文件，错误时，哈希值中的 success 将为 false，error 将包含任何错误：
{
"success": false、
"error"："Authorized ips contain invalid IP 441.2.3.4 on line 1, Swap interval must be greater than or equal to 0" (授权的 ips 在第 1 行包含无效 IP 441.2.3.4，交换间隔必须大于或等于 0)
}添加授权 IP
该端点允许在授权 IP 列表中添加新的授权 IP，而不会为了方便而列出所有 IP。
| 终点 | /package_subscriptions/:id/add_authorized_ip |
| 方法 | 输入 |
| 必要的 HTTP 标头 | Content-Type: 应用程序/json |
| 参数 | id - 订阅的 id |
| 查询参数 | 无 |
| JSON 参数 | ip - 字符串 - 要添加的 IP 地址 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -X PUT -H "Content-Type: application/json" -u api:08c5fa8dd63c8adc4b08803df5f68f9d --data '{"ip"："1.1.1.1"}' https://app.privateproxy.me/api/v1/package_subscriptions/1/add_authorized_ip从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.put("/package_subscriptions/1/add_authorized_ip", body = {'ip': '121.23.1.25'})
print(result)
result = api.put("/package_subscriptions/1/add_authorized_ip", body = {'ip': '266.1.2.3'})
print(result)
except ProxyAPIException as e：
print(str(e))put("/package_subscriptions/1/add_authorized_ip", [
"ip" => "7.7.7.7" [ "ip" => "7.7.7.7"
]));
} catch(ProxyAPIException $e) {
echo $e；
}const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.put(
'https://app.privateproxy.me/api/v1/package_subscriptions/1/add_authorized_ip'、
'08c5fa8dd63c8adc4b08803df5f68f9d',
{
"ip"："1.2.3.4"
}
);
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.put("/package_subscriptions/1/add_authorized_ip", ip: '1.2.3.2').inspect)
puts(api.put("/package_subscriptions/1/add_authorized_ip", ip: '412.2.3.2').inspect)
rescue ProxyAPIException => e
puts e.message
结束主包
导入 (
"fmt"
"net/http"
)
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
ip := "{\"ip\"：\"1.7.2.5\"}"
resp, _, err := api.Put("/package_subscriptions/1/add_authorized_ip", ip)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
}删除授权 IP
为方便起见，该端点允许删除授权 IP，而无需列出所有 IP。如果没有提供 IP，该端点将返回错误信息，否则即使没有删除 IP，也会成功删除。
| 终点 | /package_subscriptions/:id/remove_authorized_ip |
| 方法 | 输入 |
| 必要的 HTTP 标头 | Content-Type: 应用程序/json |
| 参数 | id - 订阅的 id |
| 查询参数 | 无 |
| JSON 参数 | ip - 字符串 - 要删除的 IP 地址 |
在 *nix shell 中使用 curlPython 3 + 请求PHP + libcurlNode.js + stdlibRuby + stdlibGolang + stdlib
curl -X PUT -H "Content-Type: application/json" -u api:08c5fa8dd63c8adc4b08803df5f68f9d --data '{"ip"："1.1.1.1"}' https://app.privateproxy.me/api/v1/package_subscriptions/1/remove_authorized_ip从 proxy_api 导入 *
api = ProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
try：
result = api.put("/package_subscriptions/1/remove_authorized_ip", body = {'ip'：'121.23.1.25'})
print(result)
except ProxyAPIException as e：
print(str(e))put("/package_subscriptions/1/remove_authorized_ip", [
"ip" => "7.7.7.7" [ "ip" => "7.7.7.7"
]));
} catch(ProxyAPIException $e) {
echo $e；
}const proxy_api = require('./proxy_api')；
async 函数 main() {
const res = await proxy_api.put(
'https://app.privateproxy.me/api/v1/package_subscriptions/1/remove_authorized_ip'、
'08c5fa8dd63c8adc4b08803df5f68f9d',
{
"ip"："1.2.3.4"
}
);
if (res instanceof Error) {
console.log("Error:")+ res.toString())；
} else {
console.log(res)；
}
}
main()；require_relative './proxy_api
开始
api = ProxyAPI.new("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d")
puts(api.put("/package_subscriptions/1/add_authorized_ip", ip: '11.22.33.212').inspect)
rescue ProxyAPIException => e
puts e.message
结束主包
导入 (
"fmt"
"net/http"
)
func main() {
api := NewProxyAPI("https://app.privateproxy.me/api/v1", "08c5fa8dd63c8adc4b08803df5f68f9d", &http.Client{})
ip := "{\"ip\"：\"1.7.2.5\"}"
resp, _, err := api.Put("/package_subscriptions/1/remove_authorized_ip", ip)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(resp)
}
}Last Updated on 2 月 22, 2023
Chinese