標識








概述
如何使用
獲取代理
產品
代理
  • Socks5代理
  • 住宅代理
  • 無限住宅代理
  • 數據中心代理
  • 靜態住宅代理
  • 輪換 ISP 代理
選單
我的帳戶
ABC錢包 NEW
企業CDK兌換
推薦計劃 10% 佣金
文檔和幫助
  • 文檔
  • 使用者指南
  • 視頻指南







貴賓
獲取代理
用戶及密碼驗證
API 提取
代理管理器
認證帳戶管理
IP白名單配置
例子

{{userInfo.flow_balance}}G

---

住宅代理計劃(流量)
充值

{{userInfo.static_no_count}} IPs

---

可用IP

靜態住宅計劃
充值

{{farmsDay(userInfo.pack_last_time)}}

---

可用時間

無限流量套餐(流量)
充值

{{userInfo.exclusive_balance}} IPs

---

可用IP

數據中心代理
充值

{{userInfo.flow_isp}}G

---

輪換 ISP 代理
充值
代理生成器

代理IP池選擇

{{ item.label }}
選擇精確代理或保留隨機代理 位置。

地區

項目值 項目值 {{ item.label }}
這是你的最終IP:端口
提示:如果選擇默認,則會匹配到中的伺服器 IP所在地區。

代理地址

選擇IP

其他搜尋方式

黏性:保持同一IP位址最多90分鐘 一個粘性會話。
輪換:選擇一個輪換會話,每次輪換都會獲得一個新IP 要求。

IP模式

IP持續時間 (1-120 分分鐘)

互聯網服務供應商

州/省

城市

您可以透過以下方式建立並指派流量給子帳戶 您自己,或直接使用您的主帳戶。

子用戶

或者

創建用戶

用戶名

密碼

測試命令

複製

產生代理列表

代理格式

數量

介面參數
強制的

代理池身份

地區
非強制性

區域,不填預設全域混合分配

英石
非強制性

狀態,某些國家包含,如果留空則預設為隨機

城市
非強制性

城市,如果留空則預設為隨機

會議
非強制性

需要固定IP時配置,使用者自訂

會話時間
非強制性

與會話搭配使用,配置IP老化時間,可達 至 120 分鐘

例子

區-代理池 ID
[帳戶]-區域 abc:[密碼]
例子
#捲曲-x ***.abcproxy.com:4951 -你」[帳戶]-區域 abc:[密碼]" ipinfo.io


地區-指定區域
[帳戶]-區域-abc-美國地區:[密碼]
美國地區 美國
例子
#捲曲-x ***.abcproxy.com:4951 -U "[帳戶]-區域-abc-美國地區:[密碼]" ipinfo.io

英石-指定國家
[帳戶]-區域-abc-區域-美國-加州:[密碼]
聖加州 加州
例子
#捲曲-x ***.abcproxy.com::4951 -U "[帳戶]-區域-abc-區域-美國-加州:[密碼]" ipinfo.io

城市-指定城市
[帳戶]-區域-abc-地區-美國-加州-城市-紐約:[密碼]
紐約市紐約
例子
#捲曲-x ***.abcproxy.com:4951 -U "[帳戶]-區域-abc-地區-美國-加州-城市-紐約:[密碼]" ipinfo.io

會議-修復了導出ip
sed 指定您要在一段時間內修復退出 IP 時間,不指定預設值 5 分鐘
[帳戶]-區域-abc-地區-美國-加州-城市-紐約-會話-b5b36885:[密碼]
會議
例子
#捲曲-x ***.abcproxy.com:4951-U "[帳戶]-區域-abc-地區-美國-加州-城市-紐約-會話-b5b36885:[密碼]" ipinfo.io

會話時間- 指定最長持續時間為 120 分鐘的退出 IP
與會話一起使用來指定固定的退出 IP 生存時間
[帳戶]-區域-abc-地區-美國-加利福尼亞-城市-紐約-會話-b5b36885-會話時間-120:[密碼]
會話時間-120 120 分分鐘
例子
#捲曲-x ***.abcproxy.com:4951-U "[帳戶]-區域-abc-地區-美國-加利福尼亞-城市-紐約-會話-b5b36885-會話時間-120:[密碼]" ipinfo.io

後退

代理列表

批量删除
諾皮克 挑選 名称
建立日期、時間
地區
會話類型
用戶名:密碼
數量
行動
諾皮克 挑選 {{info.name}}
編輯
保存
{{formatDateVue(info.create_time)}}
{{info.region}}{{info.state !="" ? "-"+info.state : "" }}{{info.city !="" ? "-"+info.city : "" }}
{{info.ip_mode == "rotating" ? info.ip_mode : info.ip_mode +"-"+ info.ip_duration }}
{{info.sub_username}}:{{info.password}}
{{info.quantity}}
导出
刪除

{{userInfo.flow_balance}}G

---

住宅代理計劃(流量)
充值

{{userInfo.static_no_count}} IPs

---

可用IP

靜態住宅計劃
充值

{{farmsDay(userInfo.pack_last_time)}}

---

可用時間

無限流量套餐(流量)
充值

{{userInfo.exclusive_balance}} IPs

---

可用IP

數據中心代理
充值
代理生成器

模式

提取量

選擇地區

國家 國家

{{info.label}}

看更多 >

選擇地區

選擇地區

黏性:在黏性會話中保持相同的IP位址5分鐘。
輪換:選擇一個輪換會話,為每個請求取得一個新的IP。

IP模式

其他設定

協定

格式

分隔器


選擇地區

受歡迎的

國家 國家

{{info.label}}

其他的

{{info.label}}({{info.value}})
確認

測試命令

API參數說明
編號

數數

地區

國家

協定

協定

返回類型

格式:TXT JSON

分隔符 ( 1:\ r \ n2:/ br 3:\r 4:\n5:\t6:自訂分隔符 )

英石

自訂分隔符

例子

{
    "代碼” : 0,
    "成功”: 真的,
    "味精”: "0",
    "要求_ip": "請求地址”,
    "數據”: [
    {"ip": "47.244.192.12","港口”: 15698}
   ]
}

結果註釋
程式碼

0 表示成功,I表示失敗

ip

IP

成功

True表示成功,False表示失敗

港口

港口

認證帳戶管理

帳戶名稱 密碼 流量使用限制 流量消耗 添加時間 状态 評論 操作
    關閉

    提示

    刪除帳號後,帳號密碼失效, 確認刪除?

    取消
    確認
    關閉

    認證帳號

    * 帳戶名稱
    * 密碼
    流量限制 G
    評論
    状态

    停用 啓用

    使能夠 禁用

    取消
    確認

    IP白名單配置

    目前IP ***.***.***.***
    + 新增白名單
    IP 添加時間 備注 狀態 操作

      白名單API介面

      目的 API連結
      新增白名單
      刪除白名單
      查看白名單
      關閉

      提示

      刪除IP後,IP失效,是否確認刪除?

      取消
      確認
      關閉

      新增白名單

      * IP位址
      評論
      取消
      確認

      遇到問題? 聯絡我們

      例子

      
      
      
                #include "stdafx.h"
                #include "curl/curl.h"
                #pragma comment(lib, "libcurl.lib")
                static size_t write_buff_data(char *buffer, size_t size, size_t nitems, void *outstream)
                {
                  memcpy(outstream, buffer, nitems*size);
                  return nitems*size;
                }
                
                int GetUrlHTTP(char *url, char *buff)
                {
                  CURL *curl;
                  CURLcode res;
                  curl = curl_easy_init();
                  if (curl)
                  {
                    curl_easy_setopt(curl, CURLOPT_PROXY,"http://host:port");
                    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "users:password");
                    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);
                    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);
                    curl_easy_setopt(curl, CURLOPT_URL, url);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);
                    curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);
                
                    res = curl_easy_perform(curl);
                    curl_easy_cleanup(curl);
                    if (res == CURLE_OK){
                      return res;
                    }else {
                      printf("error:%d\n", res);
                      MessageBox(NULL, TEXT("Get Ip Error"), TEXT("Help"), MB_ICONINFORMATION | MB_YESNO);
                    }
                  }
                  return res;
                }
                
                int GetUrlSocks5(char *url, char *buff)
                {
                  CURL *curl;
                  CURLcode res;
                  curl = curl_easy_init();
                  if (curl)
                  {
                    curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://host:port");
                    curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "users:password");
                    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);
                    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);
                    curl_easy_setopt(curl, CURLOPT_URL, url);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);
                    curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);
                    res = curl_easy_perform(curl);
                    curl_easy_cleanup(curl);
                    if (res == CURLE_OK) {
                      return res;
                    }
                    else {
                      printf("error:%d\n", res);
                      MessageBox(NULL, TEXT("Get Ip Error"), TEXT("Help"), MB_ICONINFORMATION | MB_YESNO);
                    }
                  }
                  return res;
                }
                
                int GetUrl(char *url, char *buff)
                {
                  CURL *curl;
                  CURLcode res;
                  curl = curl_easy_init();
                  if (curl)
                  {
                    curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);
                    curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);
                    curl_easy_setopt(curl, CURLOPT_URL, url);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);
                    curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);
                    curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);
                    res = curl_easy_perform(curl);
                    curl_easy_cleanup(curl);
                    if (res == CURLE_OK)
                    {
                      return res;
                    }
                    else {
                      printf("error:%d\n", res);
                      MessageBox(NULL, TEXT("Get Ip Error"), TEXT("Help"), MB_ICONINFORMATION | MB_YESNO);
                    }
                  }
                  return res;
                }
                
                int main()
                {
                  char *buff=(char*)malloc(1024*1024);
                  memset(buff, 0, 1024 * 1024);
                  //Test 1
                  GetUrl("http://ipinfo.io", buff);
                  printf("No Proxy:%s\n", buff);
                  //Test 2
                  memset(buff, 0, 1024 * 1024);
                  GetUrlHTTP("http://ipinfo.io", buff);
                  printf("Proxy By Http:%s\n", buff);
                  //Test 3
                  memset(buff, 0,1024 * 1024);
                  GetUrlSocks5("http://ipinfo.io", buff);
                  printf("Proxy by socks5:%s\n", buff);
                
                  Sleep(1000 * 1000);
                  free(buff);
                    return 0;
                }
                
      
      
      package main
      
      
      
      import (
            
          "context"
            
          "fmt"
            
          "golang.org/x/net/proxy"
            
          "io/ioutil"
            
          "net"
            
          "net/http"
            
          "net/url"
            
          "strings"
            
          "time"
            
      )
            
            
            
      var testApi = "https://api.myip.la/en?json"
            
            
            
      func main() {
            
          getMyIp()
            
            
            
          //Accounts
            
          var proxyIP = "ip:port"
            
          go httpProxy(proxyIP, "", "")
            
          go Socks5Proxy(proxyIP, "", "")
            
          time.Sleep(time.Minute)
            
      }
            
            
            
      func getMyIp() {
            
          rsp, err := http.Get("https://api.myip.la/en?json")
            
          if err != nil {
            
              fmt.Println("Failed to get native IP", err.Error())
            
              return
            
          }
            
          defer rsp.Body.Close()
            
          body, err := ioutil.ReadAll(rsp.Body)
            
          if err != nil {
            
              fmt.Println(err.Error())
            
              return
            
          }
            
          fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "local ip:", string(body))
            
            
            
      }
            
            
            
      //http proxy
            
      func httpProxy(proxyUrl, user, pass string) {
            
          defer func() {
            
              if err := recover(); err != nil {
            
        fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "http", "Return information:", err)
            
              }
            
          }()
            
          urli := url.URL{}
            
            
            
          if !strings.Contains(proxyUrl, "http") {
            
              proxyUrl = fmt.Sprintf("http://%s", proxyUrl)
            
          }
            
            
            
          urlProxy, _ := urli.Parse(proxyUrl)
            
          if user != "" && pass != "" {
            
              urlProxy.User = url.UserPassword(user, pass)
            
          }
            
            
            
          client := &http.Client{
            
              Transport: &http.Transport{
            
        Proxy: http.ProxyURL(urlProxy),
            
              },
            
          }
            
          rqt, err := http.NewRequest("GET", testApi, nil)
            
          if err != nil {
            
              panic(err)
            
              return
            
          }
            
          response, err := client.Do(rqt)
            
          if err != nil {
            
              panic(err)
            
              return
            
          }
            
            
            
          defer response.Body.Close()
            
          body, _ := ioutil.ReadAll(response.Body)
            
          fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "【http success】", "Return information:", response.Status, string(body))
            
            
            
          return
            
      }
            
            
            
      //Socks5 proxy
            
      func Socks5Proxy(proxyUrl, user, pass string) {
            
            
            
          defer func() {
            
              if err := recover(); err != nil {
            
        fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, " Return information:", err)
            
              }
            
          }()
            
            
            
          var userAuth proxy.Auth
            
          if user != "" && pass != "" {
            
              userAuth.User = user
            
              userAuth.Password = pass
            
          }
            
          dialer, err := proxy.SOCKS5("tcp", proxyUrl, &userAuth, proxy.Direct)
            
          if err != nil {
            
              panic(err)
            
          }
            
          httpClient := &http.Client{
            
              Transport: &http.Transport{
            
        DialContext: func(ctx context.Context, network, addr string) (conn net.Conn, err error) {
            
            return dialer.Dial(network, addr)
            
        },
            
              },
            
              Timeout: time.Second * 10,
            
          }
            
            
            
          //Request Network
            
          if resp, err := httpClient.Get(testApi); err != nil {
            
              panic(err)
            
          } else {
            
              defer resp.Body.Close()
            
              body, _ := ioutil.ReadAll(resp.Body)
            
              fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "【socks5 success】", " Return information:", string(body))
            
          }
            
      }
      
      
      #!/usr/bin/env node
      
      require('request-promise')({
      
          url: 'https://ipinfo.io',
      
          proxy: 'http://ip:port',
          
          })
      
      .then(function(data){ console.log(data); },
      
          function(err){ console.error(err); });
            
      
      
      <?php
      
      // Target page to visit
            
      $targetUrl = "www.google.com";
            
      // proxy server
            
      $proxyServer = "http://{{ip}:{{domain}}";
            
            
            
      // Tunnel Identity Information
            
      $ch = curl_init();
            
      curl_setopt($ch, CURLOPT_URL, $targetUrl);
            
      curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
            
      curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
            
            
            
      // Setting up a proxy server
            
      curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
            
      // curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
            
      curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
            
            
            
      // Set Tunnel Verification Information
            
      curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
            
      curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");
            
      curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
            
      curl_setopt($ch, CURLOPT_TIMEOUT, 5);
            
      curl_setopt($ch, CURLOPT_HEADER, true);
            
      curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
            
      $result = curl_exec($ch);
            
      $err = curl_error($ch);
            
            
            
      curl_close($ch);
            
            
            
      var_dump($err);
            
      var_dump($result);
      
      
      package demo;
      
      
      
          import okhttp3.OkHttpClient;
      
          import okhttp3.Request;
      
      
      
          import java.io.IOException;
      
          import java.net.InetSocketAddress;
      
          import java.net.Proxy;
      
      
      
          /**
      
          * compile 'com.squareup.okhttp3:okhttp:3.10.0'
      
          */
      
          class ApiProxyJava {
      
              public static void main(String[] args) throws IOException {
      
        testHttpWithOkHttp();
      
        testSocks5WithOkHttp();
      
              }
      
      
      
              public static void testHttpWithOkHttp() throws IOException {
      
        String url = "http://api.myip.la/en?json";
      
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("ip", 2000));
      
        OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
      
      
      
        Request request = new Request.Builder().url(url).build();
      
        okhttp3.Response response = client.newCall(request).execute();
      
        String responseString = response.body().string();
      
        System.out.println(responseString);
      
              }
      
      
      
              public static void testSocks5WithOkHttp() throws IOException {
      
        String url = "http://api.myip.la/en?json";
      
        Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("ip", 8080));
      
        OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
      
      
      
        Request request = new Request.Builder().url(url).build();
      
        okhttp3.Response response = client.newCall(request).execute();
      
        String responseString = response.body().string();
      
        System.out.println(responseString);
      
              }
      
          }
      
            
      
      
      # coding=utf-8
      
      # !/usr/bin/env python
            
      import json
            
      import threading
            
      import time
            
      import requests as rq
            
            
            
      headers = {
            
          "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:85.0) Gecko/20100101 Firefox/85.0",
            
          "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
            
          "Accept-Language": "zh-CN,zh;q=0.8,zh-TW;q=0.7,zh-HK;q=0.5,en-US;q=0.3,en;q=0.2",
            
          "Accept-Encoding": "gzip, deflate, br"
            
      }
            
      testUrl = 'https://api.myip.la/en?json'
            
            
            
            
            
      # The core business
            
      def testPost(host, port):
            
          proxies = {
            
              'http': 'http://{}:{}'.format(host, port),
            
              'https': 'http://{}:{}'.format(host, port),
            
          }
            
          res = ""
            
            
            
          while True:
            
              try:
            
        res = rq.get(testUrl, proxies=proxies, timeout=5)
            
        # print(res.status_code)
            
        print(res.status_code, "***", res.text)
            
        break
            
              except Exception as e:
            
        print(e)
            
        break
            
            
            
          return
            
            
            
            
            
      class ThreadFactory(threading.Thread):
            
          def __init__(self, host, port):
            
              threading.Thread.__init__(self)
            
              self.host = host
            
              self.port = port
            
            
            
          def run(self):
            
              testPost(self.host, self.port)
            
            
            
            
            
      # Extract the link to the proxy  Return value of json type
            
      tiqu = 'Extract the link'
            
            
            
      while 1 == 1:
            
          # Extract 10 at a time and put them into the thread
            
          resp = rq.get(url=tiqu, timeout=5)
            
          try:
            
              if resp.status_code == 200:
            
        dataBean = json.loads(resp.text)
            
              else:
            
        print("failure")
            
        time.sleep(1)
            
        continue
            
          except ValueError:
            
              print("failure")
            
              time.sleep(1)
            
              continue
            
          else:
            
              # Parsing json arrays
            
              print("code=", dataBean["code"])
            
              code = dataBean["code"]
            
              if code == 0:
            
        threads = []
            
        for proxy in dataBean["data"]:
            
            threads.append(ThreadFactory(proxy["ip"], proxy["port"]))
            
        for t in threads:  # Open the thread
            
            t.start()
            
            time.sleep(0.01)
            
        for t in threads:  # Blocking threads
            
            t.join()
            
          # break
            
          time.sleep(1)
            
      
      ABC代理

      支付

      續訂地點:    我們*5 , 英國*10     重新選擇
      選擇續訂時間:
        全部的: $100
        折扣 (0% 離開) $4

        有優惠券代碼嗎?

        申請

        選擇您的付款方式

        ABC S5 代理自 2018 年以來受到數千家企業的信賴 安全訪問本地化內容和專業網絡爬行 解決方案。

        contact

        聯繫我們

        s

        全名

        必需的

        公司名稱

        公司名稱為必填項

        公司電子郵件地址

        電子郵件必須是有效的電子郵件地址

        電話號碼.

        ABCProxy +1

        電話號碼為必填項

        ABCProxy 將處理您的數據以管理您的詢問並通知您 關於我們的服務。 欲了解更多信息,請訪問我們的 隱私政策.