Shell语言代码示例
```shell
#!/bin/bash
targetURL="https://test.ipw.cn"
# 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
proxyAddr="您的代理IP:端口号"
authKey="请改成您的Key"
password="请改成您的AuthPwd"
curl -x ${authKey}:${password}@${proxyAddr} ${targetURL} -vvvv
```
Java语言代码示例
## Java HttpURLConnection
```java
package com.qgproxy;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.net.Authenticator;
import java.net.HttpURLConnection;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
import java.net.URL;
class QGProxyAuthenticator extends Authenticator {
private String user, password;
public QGProxyAuthenticator(String user, String password) {
this.user = user;
this.password = password;
}
protected PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(user, password.toCharArray());
}
}
class QGProxy {
public static void main(String args[]) {
// 如果您的本地jdk版本在Java 8 Update 111以上，需要增加以下代码
// System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "false");
// System.setProperty("jdk.http.auth.proxying.disabledSchemes", "false");
String targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
String proxyIp = "您的代理IP";
int proxyPort = 端口号;
String authKey = "请改成您的Key";
String password = "请改成您的AuthPwd";
try {
URL url = new URL(targetUrl);
Authenticator.setDefault(new QGProxyAuthenticator(authKey, password));
InetSocketAddress socketAddress = new InetSocketAddress(proxyIp, proxyPort);
Proxy proxy = new Proxy(Proxy.Type.HTTP, socketAddress);
HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
byte[] response = readStream(connection.getInputStream());
System.out.println(new String(response));
} catch (Exception e) {
System.out.println(e.getLocalizedMessage());
}
}
public static byte[] readStream(InputStream inStream) throws Exception {
ByteArrayOutputStream outSteam = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len = -1;
while ((len = inStream.read(buffer)) != -1) {
outSteam.write(buffer, 0, len);
}
outSteam.close();
inStream.close();
return outSteam.toByteArray();
}
}
```
## Java okhttp(4.10.0版本以上)
```java
package com.qgproxy;
import okhttp3.*;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.util.concurrent.TimeUnit;
public class QGProxy {
final static String proxyIp = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String authKey = "请改成您的Key";
final static String password = "请改成您的AuthPwd";
public Response request() throws IOException {
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyIp, proxyPort));
OkHttpClient client = new OkHttpClient.Builder()
.proxy(proxy)
.proxyAuthenticator((route, response) -> {
String credential = Credentials.basic(authKey, password);
return response.request().newBuilder().header("Proxy-Authorization", credential).build();
}).
build();
Request request = new Request.Builder().url("https://api.ipify.org").get().build();
return client.newCall(request).execute();
}
public static void main(String[] args) {
QGProxy qgProxy = new QGProxy();
try {
Response resp = qgProxy.request();
System.out.println(resp.body().string());
} catch (Exception e) {
System.out.printf("failed to proxy: %s\n", e.getMessage());
}
}
}
```
## Java jsoup
```java
package com.qgproxy;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Document;
import java.io.IOException;
import java.net.Authenticator;
import java.net.InetSocketAddress;
import java.net.PasswordAuthentication;
import java.net.Proxy;
public class QGProxy {
final static String proxyIp = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String authKey = "请改成您的Key";
final static String password = "请改成您的AuthPwd";
public static void main(String[] args) throws Exception {
String targetUrl = "https://test.ipw.cn";
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
Authenticator.setDefault(new Authenticator() {
public PasswordAuthentication getPasswordAuthentication() {
return new PasswordAuthentication(authKey, password.toCharArray());
}
});
// 如果您的本地jdk版本在Java 8 Update 111以上，需要增加以下代码
// System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "false");
// System.setProperty("jdk.http.auth.proxying.disabledSchemes", "false");
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyIp, proxyPort));
try {
Document doc = Jsoup.connect(targetUrl).ignoreContentType(true).timeout(10000).proxy(proxy).get();
if (doc != null) {
System.out.println(doc.body().html());
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
## Java HttpClient 3.X
```java
package com.qgproxy;
import java.io.IOException;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
public class QGProxy {
public static void main(String[] args) {
String targetUrl = "https://test.ipw.cn"; // 访问的目标站点
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
String proxyIp = "您的代理IP";
int proxyPort = 端口号;
String authKey = "请改成您的Key";
String password = "请改成您的AuthPwd";
try {
HttpHost proxy = new HttpHost(proxyIp, proxyPort, "http");
HttpHost target = new HttpHost(targetUrl, 80);
// 设置认证
CredentialsProvider provider = new BasicCredentialsProvider();
provider.setCredentials(new AuthScope(proxy), new UsernamePasswordCredentials(authKey, password));
CloseableHttpClient httpClient = HttpClients.custom().setDefaultCredentialsProvider(provider).build();
RequestConfig config = RequestConfig.custom().setProxy(proxy).build();
HttpGet httpGet = new HttpGet("/ip");
httpGet.setConfig(config);
CloseableHttpResponse resp = null;
resp = httpClient.execute(target, httpGet);
if (resp.getStatusLine().getStatusCode() == 200) {
System.out.println("OK");
}
System.out.println(resp.getStatusLine());
} catch (IOException e) {
e.printStackTrace();
}
}
}
```
## Java HttpClient 4.X
```java
package com.qgproxy
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.IOException;
import java.net.URI;
import java.util.Arrays;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.apache.http.Header;
import org.apache.http.HeaderElement;
import org.apache.http.HttpHost;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.AuthCache;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.HttpRequestRetryHandler;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.config.AuthSchemes;
import org.apache.http.client.entity.GzipDecompressingEntity;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpRequestBase;
import org.apache.http.client.protocol.HttpClientContext;
import org.apache.http.config.Registry;
import org.apache.http.config.RegistryBuilder;
import org.apache.http.conn.socket.ConnectionSocketFactory;
import org.apache.http.conn.socket.LayeredConnectionSocketFactory;
import org.apache.http.conn.socket.PlainConnectionSocketFactory;
import org.apache.http.conn.ssl.SSLConnectionSocketFactory;
import org.apache.http.impl.auth.BasicScheme;
import org.apache.http.impl.client.BasicAuthCache;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.impl.client.ProxyAuthenticationStrategy;
import org.apache.http.impl.conn.PoolingHttpClientConnectionManager;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.NameValuePair;
import org.apache.http.util.EntityUtils;
public class QGProxy {
final static String proxyHost = "您的代理IP";
final static Integer proxyPort = 端口号;
final static String proxyUser = "请改成您的key";
final static String proxyPass = "请改成您的password";
private static PoolingHttpClientConnectionManager cm = null;
private static HttpRequestRetryHandler httpRequestRetryHandler = null;
private static HttpHost proxy = null;
private static CredentialsProvider credsProvider = null;
private static RequestConfig reqConfig = null;
static {
ConnectionSocketFactory plainsf = PlainConnectionSocketFactory.getSocketFactory();
LayeredConnectionSocketFactory sslsf = SSLConnectionSocketFactory.getSocketFactory();
Registry registry = RegistryBuilder.create()
.register("http", plainsf)
.register("https", sslsf)
.build();
cm = new PoolingHttpClientConnectionManager(registry);
cm.setMaxTotal(10);
cm.setDefaultMaxPerRoute(5);
proxy = new HttpHost(proxyHost, proxyPort, "http");
credsProvider = new BasicCredentialsProvider();
credsProvider.setCredentials(AuthScope.ANY, new UsernamePasswordCredentials(proxyUser, proxyPass));
reqConfig = RequestConfig.custom()
.setExpectContinueEnabled(false)
.setProxy(new HttpHost(proxyHost, proxyPort))
.build();
}
public static void doRequest(HttpRequestBase httpReq) {
CloseableHttpResponse httpResp = null;
try {
httpReq.setConfig(reqConfig);
CloseableHttpClient httpClient = HttpClients.custom()
.setConnectionManager(cm)
.setDefaultCredentialsProvider(credsProvider)
.build();
AuthCache authCache = new BasicAuthCache();
authCache.put(proxy, new BasicScheme());
authCache.put(proxy, new BasicScheme(ChallengeState.PROXY));
HttpClientContext localContext = HttpClientContext.create();
localContext.setAuthCache(authCache);
httpResp = httpClient.execute(httpReq, localContext);
System.out.println(httpResp.getStatusLine().getStatusCode(););
BufferedReader rd = new BufferedReader(new InputStreamReader(httpResp.getEntity().getContent()));
String line = "";
while((line = rd.readLine()) != null) {
System.out.println(line);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
if (httpResp != null) {
httpResp.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
public static void main(String[] args) {
String targetUrl = "https://api.ipify.org";
try {
HttpGet httpGet = new HttpGet(targetUrl);
doRequest(httpGet);
} catch (Exception e) {
e.printStackTrace();
}
}
}
```
PHP语言代码示例
## PHP curl
```php
/**
* 请求
*
* @param [type] $targetUrl 目标站点
* @param [type] $proxyIp 代理ip
* @param [type] $proxyPort 代理端口
* @param [type] $proxyUser AuthKey
* @param [type] $proxyPassword AuthPwd
* @return void
*/
function sendRequest($targetUrl, $proxyIp, $proxyPort, $proxyUser, $proxyPassword){
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $targetUrl);
curl_setopt($ch, CURLOPT_HEADER, 0);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($ch, CURLOPT_PROXYPORT, $proxyPort);
curl_setopt($ch, CURLOPT_PROXYTYPE, 'HTTP');
curl_setopt($ch, CURLOPT_PROXY, $proxyIp);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUser . ':' . $proxyPassword);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
$data = curl_exec($ch);
curl_close($ch);
return $data;
}
$data = sendRequest('https://test.ipw.cn', '请改成您的代理IP', 端口号, '请改成您的Key', '请改成您的AuthPwd');
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
var_dump($data);
```
## PHP stream
```php
/**
* 请求
*
* @param [type] $targetUrl 目标站点
* @param [type] $proxyIp 代理ip
* @param [type] $proxyPort 代理端口
* @param [type] $proxyUser AuthKey
* @param [type] $proxyPassword AuthPwd
* @return void
*/
function sendRequest($targetUrl, $proxyIp, $proxyPort, $proxyUser, $proxyPassword){
$proxyAuth = base64_encode($proxyUser . ":" . $proxyPassword);
$headers = implode("\r\n", [
"Proxy-Authorization: Basic {$proxyAuth}"
]);
// 目标站为https时需要
// $sniServer = parse_url($targetUrl, PHP_URL_HOST);
$options = [
"http" => [
"proxy" => $proxyIp . ':' . $proxyPort,
"header" => $headers,
"method" => "GET",
"request_fulluri" => true,
],
// 目标站为https时需要
// 'ssl' => array(
// 'SNI_enabled' => true,
// 'SNI_server_name' => $sniServer
// )
];
$context = stream_context_create($options);
$result = file_get_contents($targetUrl, false, $context);
return $result;
}
$data = sendRequest('https://test.ipw.cn', '请改成您的代理IP', 端口号, '请改成您的Key', '请改成您的AuthPwd');
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
var_dump($data);
```
## PHP GuzzleHttp
```PHP
/**
* 请求
*
* @param [type] $targetUrl 目标站点
* @param [type] $proxyIp 代理ip
* @param [type] $proxyPort 代理端口
* @param [type] $proxyUser AuthKey
* @param [type] $proxyPassword AuthPwd
* @return void
*/
function sendRequest($targetUrl, $proxyIp, $proxyPort, $proxyUser, $proxyPassword){
$client = new \GuzzleHttp\Client();
$proxyAuth = base64_encode($proxyUser . ":" . $proxyPassword);
$options = [
"proxy" => $proxyIp . ':' . $proxyPort,
"headers" => [
"Proxy-Authorization" => "Basic " . $proxyAuth
]
];
$result = $client->request('GET', $targetUrl, $options);
return $result->getBody()->getContents();
}
$data = sendRequest('https://test.ipw.cn', '请改成您的代理IP', 端口号, '请改成您的Key', '请改成您的AuthPwd');
# 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
var_dump($data);
```
Go语言代码示例
```go
package main
import (
"fmt"
"io/ioutil"
"net/http"
"net/url"
)
func main() {
authKey := "请改成您的Key"
password := "请改成您的AuthPwd"
proxyServer := "您的代理IP:端口号"
targetURL := "https://test.ipw.cn"
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
rawURL := fmt.Sprintf("http://%s:%s@%s", authKey, password, proxyServer)
proxyUrl, err := url.Parse(rawURL)
if err != nil {
panic(err)
}
client := http.Client{
Transport: &http.Transport{
Proxy: http.ProxyURL(proxyUrl),
},
}
req, _ := http.NewRequest("GET", targetURL, nil)
rsp, err := client.Do(req)
if err != nil {
fmt.Printf("request failed: %s\n", err)
return
}
defer rsp.Body.Close()
body, err := ioutil.ReadAll(rsp.Body)
if err != nil {
fmt.Println(err)
} else {
fmt.Println(string(body))
}
}
```
C语言代码示例
```c++
#include
#include
#include
#include "curl/curl.h"
using namespace std;
static size_t WriteMemoryCallback(void* ptr, size_t size, size_t nmemb, void* stream) {
size_t nsize = size * nmemb;
string* strdata = (string*)stream;
if (strdata)
strdata->append((const char*)ptr, nsize);
return nsize;
}
void Proxy(string& resp) {
CURL* curl = curl_easy_init();
CURLcode res;
if (curl) {
curl_easy_setopt(curl, CURLOPT_URL, "https://test.ipw.cn");
// 如果上面目标站不可用，请使用ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
curl_easy_setopt(curl, CURLOPT_PROXY, "http://代理IP:端口号");
curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "请改成您的Key:请改成您的AuthPwd");
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteMemoryCallback);
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &resp);
res = curl_easy_perform(curl);
curl_easy_cleanup(curl);
if (res != CURLE_OK) {
fprintf(stderr, "request failed: %s\n", curl_easy_strerror(res));
}
}
}
int main() {
string response;
Proxy(response);
cout << response << endl;
return 0;
}
```
Python语言代码示例
## Python requests
```python
import requests
# 如果下面目标站不可用，请使用test.ipw.cn、ip.sb、ipinfo.io、ip-api.com、64.ipcheck.ing
targetURL = "https://test.ipw.cn"
proxyAddr = "您的代理IP:端口"
authKey = "请改成您的Key"
password = "请改成您的AuthPwd"
# 账密模式
proxyUrl = "http://%(user)s:%(password)s@%(server)s" % {
"user": authKey,
"password": password,
"server": proxyAddr,
}
proxies = {
"http": proxyUrl,
"https": proxyUrl,
}
resp = requests.get(targetURL, proxies=proxies)
print(resp.text)
```
## Python aiohttp
```python
import aiohttp,asyncio
targetURL = "https://api.ipify.org"
proxyAddr = "您的代理IP:端口"
authKey = "请改成您的Key"
password = "请改成您的AuthPwd"
# 账密模式
proxyUrl = "http://%(user)s:%(password)s@%(server)s" % {
"user": authKey,
"password": password,
"server": proxyAddr,
}
async def entry():
conn = aiohttp.TCPConnector(ssl=False)
async with aiohttp.ClientSession(connector=conn) as session:
async with session.get(targetURL, proxy=proxyUrl) as resp:
body = await resp.read()
print(resp.status)
print(body)
loop = asyncio.get_event_loop()
loop.run_until_complete(entry())
loop.run_forever()
```
## Python urllib2、urllib
```python
import urllib2
targetURL = "https://api.ipify.org"
proxyAddr = "您的代理IP:端口"
authKey = "请改成您的Key"
password = "请改成您的AuthPwd"
proxyUrl = "http://%(user)s:%(password)s@%(server)s" % {
"user": authKey,
"password": password,
"server": proxyAddr,
}
proxies = urllib2.ProxyHandler({
"http": proxyUrl,
"https": proxyUrl,
})
opener = urllib2.build_opener(proxies)
urllib2.install_opener(opener)
resp = urllib2.urlopen(targetURL).read()
print(resp)
```
短效代理（全球HTTP）-通道提取-查询在用IP资源接口
## 1. 接口描述
接口请求域名： overseas.proxy.qg.net。
本接口 (/query) 用于全球HTTP-短效代理产品通道提取模式下查询在用的IP资源的接口。
默认接口请求频率限制：60次/分钟。
推荐使用调试工具进行调试，[调试工具](https://www.qg.net/tools/IPdebug.html?type=5-2)。
## 2. 输入参数
| 参数名称 | 必选 | 类型 | 描述 |
| -------- | ---- | ------ | ------------------------ |
| key | 是 | String | 公共参数，产品唯一标识。 |
## 3. 输出参数
| 参数名称 | 类型 | 描述 |
| ---------- | ----------------------------------------------- | ------------------------------------------------------------ |
| code | String | 请求状态码。 |
| data | Array of [IP](https://www.qg.net/doc/1839.html) | IP资源列表。
**注：IP结构中的server才是代理地址，proxy_ip是代理的真实出口IP。** |
| request_id | String | 唯一请求ID，每次请求都会返回。定位问题时需要提供该次请求的 request_id。 |
## 4. 示例
#### 输入示例
```
GET https://overseas.proxy.qg.net/query?key=<您的key信息>&<其他输入参数>
```
#### 输出示例
```json
{
"code": "SUCCESS",
"data": [{
"proxy_ip": "129.150.42.240",
"server": "129.150.42.240:18080",
"area": "新加坡",
"deadline": "2023-02-25 15:38:36"
}],
"request_id": "83158ebe-be6c-40f7-a158-688741083edc"
}
```
## 5. 错误码
| 错误码 | 描述 |
| ---------------------- | ------------------------------------------------------------ |
| INTERNAL_ERROR | 系统内部异常。 |
| INVALID_PARAMETER | 参数错误（包含参数格式、类型等错误）。 |
| INVALID_KEY | Key不存在或已过期。 |
| UNAVAILABLE_KEY | Key不可用，已过期或被封禁 |
| ACCESS_DENY | Key没有此接口的权限。 |
| API_AUTH_DENY | Api授权不通过，请检查[Api鉴权配置](https://www.qg.net/user/proxyIpManage)。 |
| KEY_BLOCK | Key被封禁。 |
| REQUEST_LIMIT_EXCEEDED | 请求频率超出限制。 |
短效代理（全球HTTP）-按量提取-查询在用IP资源接口
## 1. 接口描述
接口请求域名： overseas.proxy.qg.net。
本接口 (/query) 用于全球HTTP-短效代理产品按量提取模式下查询在用的IP资源的接口。
默认接口请求频率限制：60次/分钟。
推荐使用调试工具进行调试，[调试工具](https://www.qg.net/tools/IPdebug.html?type=5-2)。
## 2. 输入参数
| 参数名称 | 必选 | 类型 | 描述 |
| -------- | ---- | ------ | ------------------------ |
| key | 是 | String | 公共参数，产品唯一标识。 |
## 3. 输出参数
| 参数名称 | 类型 | 描述 |
| ---------- | ----------------------------------------------- | ------------------------------------------------------------ |
| code | String | 请求状态码。 |
| data | Array of [IP](https://www.qg.net/doc/1839.html) | IP资源列表。
**注：IP结构中的server才是代理地址，proxy_ip是代理的真实出口IP。** |
| request_id | String | 唯一请求ID，每次请求都会返回。定位问题时需要提供该次请求的 request_id。 |
## 4. 示例
#### 输入示例
```
GET https://overseas.proxy.qg.net/query?key=<您的key信息>&<其他输入参数>
```
#### 输出示例
```json
{
"code": "SUCCESS",
"data": [{
"proxy_ip": "129.150.42.240",
"server": "129.150.42.240:18080",
"area": "新加坡",
"deadline": "2023-02-25 15:38:36"
}],
"request_id": "83158ebe-be6c-40f7-a158-688741083edc"
}
```
## 5. 错误码
| 错误码 | 描述 |
| ---------------------- | ------------------------------------------------------------ |
| INTERNAL_ERROR | 系统内部异常。 |
| INVALID_PARAMETER | 参数错误（包含参数格式、类型等错误）。 |
| INVALID_KEY | Key不存在或已过期。 |
| UNAVAILABLE_KEY | Key不可用，已过期或被封禁 |
| ACCESS_DENY | Key没有此接口的权限。 |
| API_AUTH_DENY | Api授权不通过，请检查[Api鉴权配置](https://www.qg.net/user/proxyipResource)。 |
| KEY_BLOCK | Key被封禁。 |
| REQUEST_LIMIT_EXCEEDED | 请求频率超出限制。 |
独享代理-替换IP资源接口
## 1. 接口描述
接口请求域名： exclusive.proxy.qg.net。
本接口 (/replace) 用于独享代理产品释放并重新提取IP资源的接口。
默认接口请求频率限制：60/分钟。
推荐使用调试工具进行调试，[调试工具](https://www.qg.net/tools/IPdebug.html)。
备注：调用此接口后，之前提取的资源都会被释放掉！
## 2. 输入参数
| 参数名称 | 必选 | 类型 | 描述 |
| ---------- | ---- | ------- | ------------------------------------------------------------ |
| key | 是 | String | 公共参数，产品唯一标识。 |
| area | 否 | String | 按地区提取。支持多地区筛选，逗号隔开。比如："350500,330700"。 |
| isp | 否 | Integer | 按运营商提取。
0: 不筛选
1: 电信
2: 移动
3: 联通 |
| keep_avlie | 否 | Integer | 资源存活时间，单位分钟。 |
| num | 否 | Integer | 提取个数，默认为1。 |
| distinct | 否 | Bool | 去重提取，默认为false。如果为true则不会提取到已经在使用的IP资源。 |
## 3. 输出参数
| 参数名称 | 类型 | 描述 |
| ------------ | ----------------------------------------------- | ------------------------------------------------------------ |
| code | String | 请求状态码。 |
| data.task_id | String | 提取批次的ID。 |
| data.ips | Array of [IP](https://www.qg.net/doc/1839.html) | IP资源列表。
**注：IP结构中的server才是代理地址，proxy_ip是代理的真实出口IP。** |
| data.num | Integer | 提取到的IP资源数量。 |
| request_id | String | 唯一请求ID，每次请求都会返回。定位问题时需要提供该次请求的 request_id。 |
## 4. 示例
#### 输入示例
```
GET https://exclusive.proxy.qg.net/replace?key=<您的key信息>&<其他输入参数>
```
#### 输出示例
```json
{
"code": "SUCCESS",
"data": {
"task_id": "0LIKQ3S1_task",
"ips": [
{
"proxy_ip": "123.54.55.24",
"server": "123.54.55.24:59419",
"area": "河南省商丘市",
"isp": "电信",
"deadline": "2023-02-25 15:38:36"
}
],
"num": 1
},
"request_id": "83158ebe-be6c-40f7-a158-688741083edc"
}
```
## 5. 错误码
| 错误码 | 描述 |
| ---------------------- | -------------------------------------------------------- |
| INTERNAL_ERROR | 系统内部异常。 |
| INVALID_PARAMETER | 参数错误（包含参数格式、类型等错误）。 |
| INVALID_KEY | Key不存在或已过期。 |
| UNAVAILABLE_KEY | Key不可用，已过期或被封禁 |
| ACCESS_DENY | Key没有此接口的权限。 |
| API_AUTH_DENY | Api授权不通过，请检查[Api鉴权配置](https://www.qg.net)。 |
| KEY_BLOCK | Key被封禁。 |
| REQUEST_LIMIT_EXCEEDED | 请求频率超出限制。 |
| DELETE_LIMIT_EXCEEDED | 释放频率超出限制。 |
| NO_RESOURCE_FOUND | 资源不足。 |
| FAILED_OPERATION | 提取失败。 |
独享代理-查询在用IP资源接口
## 1. 接口描述
接口请求域名： exclusive.proxy.qg.net。
本接口 (/query) 用于独享代理产品查询在用的IP资源的接口。
默认接口请求频率限制：60次/分钟。
推荐使用调试工具进行调试，[调试工具](https://www.qg.net/tools/IPdebug.html)。
## 2. 输入参数
| 参数名称 | 必选 | 类型 | 描述 |
| -------- | ---- | ------ | ------------------------------------------------------------ |
| key | 是 | String | 公共参数，产品唯一标识。 |
| task | 否 | String | 提取批次筛选。支持多批次筛选，用逗号隔开。比如："Z5p2DKKCSyhocKEa,kAEaWHucf8iPXm0O"。 |
## 3. 输出参数
| 参数名称 | 类型 | 描述 |
| ---------- | ------------------------------------------------- | ------------------------------------------------------------ |
| code | String | 请求状态码。 |
| data.tasks | Array of [Task](https://www.qg.net/doc/1839.html) | 提取批次列表。
**注：Task结构中的IP结构中的server才是代理地址，proxy_ip是代理的真实出口IP。** |
| data.num | Integer | 提取批次数量。 |
| request_id | String | 唯一请求ID，每次请求都会返回。定位问题时需要提供该次请求的 request_id。 |
## 4. 示例
#### 输入示例
```
GET https://exclusive.proxy.qg.net/query?key=<您的key信息>&<其他输入参数>
```
#### 输出示例
```json
{
"code": "SUCCESS",
"data": {
"tasks": {
"task_id": "Z5p2DKKCSyhocKEa",
"ips": [
{
"proxy_ip": "123.54.55.24",
"server": "123.54.55.24:59419",
"area": "河南省商丘市",
"isp": "电信",
"deadline": "2023-02-25 15:38:36"
}
],
"num": 1
},
"num": 1
},
"request_id": "83158ebe-be6c-40f7-a158-688741083edc"
}
```
## 5. 错误码
| 错误码 | 描述 |
| ---------------------- | ------------------------------------------------------------ |
| INTERNAL_ERROR | 系统内部异常。 |
| INVALID_PARAMETER | 参数错误（包含参数格式、类型等错误）。 |
| INVALID_KEY | Key不存在或已过期。 |
| UNAVAILABLE_KEY | Key不可用，已过期或被封禁 |
| ACCESS_DENY | Key没有此接口的权限。 |
| API_AUTH_DENY | Api授权不通过，请检查[Api鉴权配置](https://www.qg.net/user/proxyIpManage)。 |
| KEY_BLOCK | Key被封禁。 |
| REQUEST_LIMIT_EXCEEDED | 请求频率超出限制。 |
