logo








Overview
How to use
Get Proxy
Products
Proxies
  • Residential Proxies(Socks5)
  • Residential Proxies
  • Unlimited Residential Proxies
  • Dedicated Datacenter Proxies
  • Static Residential Proxies
  • Rotating ISP Proxies
Menu
My account
ABC wallet NEW
Enterprise CDK Exchange
Referral Plan 10% commission
Documentation and help
  • Documentation
  • User Guide
  • Video tutorial







vip
Get Proxy
User& Pass Auth
API Extraction
Proxy Manager
Auth Account Management
IP Whitelist Configuration
Example

{{userInfo.flow_balance}}G

---

Residential Proxy Plan(Traffic)
Recharge

{{userInfo.static_no_count}} IPs

---

Available IPs

Static Residential Plan
Recharge

{{farmsDay(userInfo.pack_last_time)}}

---

Available Times

Unlimited Plan(Traffic)
Recharge

{{userInfo.exclusive_balance}} IPs

---

Available IPs

Dedicated Datacenter Proxies
Recharge

{{userInfo.flow_isp}}G

---

Rotating ISP Proxies
Recharge
Proxy Generator

Proxy IP pool selection

{{ item.label }}
Select a precise proxy or retain the random proxy position.

Region

item.value item.value {{ item.label }}
Here is your final IP:PORT
Tips:If default is selected,it will match to the server in the region where the IP is located.

Proxy Address

Select IP

Other search methods

Sticky:Keep the same IP address for up to 90 minutes with a sticky session.
Rotate:Choose a rotating session to get a new IP with each request.

IP Mode

IP duration (1-120 minutes)

State

City

You can create and allocate traffic to sub-accounts by yourself, or directly use your main account.

Sub users

or

Create Users

Username

Password

Test Command

Copy Link

Generate Proxy List

PROXY FORMAT

QUANTITY

INTERFACE PARAMETERS
zone
mandatory

Proxy pool identity

region
Non mandatory

Region, do not fill in default global mixed allocation

st
Non mandatory

State, some countries contain, default to random if left blank

city
Non mandatory

City, default to random if left blank

session
Non mandatory

Configuration when a fixed IP is required, user-defined

SessTime
Non mandatory

Used in conjunction with a session to configure IP aging time, up to 120 minutes

EXAMPLE

zone-Proxy Pool ID
[account]-zone-abc:[password]
Example
#curl -x ***.abcproxy.com:4951 -U "[account]-zone-abc:[password]" ipinfo.io


region-designated region
[account]-zone-abc-region-us:[password]
region-us America
Example
#curl -x ***.abcproxy.com:4951 -U "[account]-zone-abc-region-us:[password]" ipinfo.io

st-designated state
[account]-zone-abc-region-us-california:[password]
st-california California
Example
#curl -x ***.abcproxy.com::4951 -U "[account]-zone-abc-region-us-california:[password]" ipinfo.io

city-designated city
[account]-zone-abc-region-us-california-city-newyork:[password]
city-newyorkNew York
Example
#curl -x ***.abcproxy.com:4951 -U "[account]-zone-abc-region-us-california-city-newyork:[password]" ipinfo.io

session-Fixed an export ip
sed to specify that you want to fix an exit IP for a period of time, without specifying a default of 5 minutes
[account]-zone-abc-region-us-california-city-newyork-session-b5b36885:[password]
session
Example
#curl -x ***.abcproxy.com:4951-U "[account]-zone-abc-region-us-california-city-newyork-session-b5b36885:[password]" ipinfo.io

SessTime- Specify an exit IP with a maximum duration of 120 minutes
Used with session to specify a fixed exit IP Time to live
[account]-zone-abc-region-us-california-city-newyork-session-b5b36885-SessTime-120:[password]
SessTime-120 120 min
Example
#curl -x ***.abcproxy.com:4951-U "[account]-zone-abc-region-us-california-city-newyork-session-b5b36885-SessTime-120:[password]" ipinfo.io

Back

Proxy list

Batch delete
nopick pick Name
Creation date, time
Region
Session type
Auth by login+pass
Number
Actions
nopick pick {{info.name}}
Edit
Save
{{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}}
Export
Delete

{{userInfo.flow_balance}}G

---

Residential Proxy Plan(Traffic)
Recharge

{{userInfo.static_no_count}} IPs

---

Available IPs

Static Residential Plan
Recharge

{{farmsDay(userInfo.pack_last_time)}}

---

Available Times

Unlimited Plan(Traffic)
Recharge

{{userInfo.exclusive_balance}} IPs

---

Available IPs

Dedicated Datacenter Proxies
Recharge
Proxy Generator

Mode

Extraction quantity

Select Region

Country Country

{{info.label}}

View more >

Select Region

Select Region

Sticky: Keep the same IP address in a sticky session for 5 minutes.
Rotate: Choose a rotation session to get a new IP for each request.

IP Mode

Other Settings

PROTOCOL

FORMAT

SEPARATOR


Select Region

Popular

Country Country

{{info.label}}

Others

{{info.label}}({{info.value}})
Confirm

TestCommand

API PARAMETER DSUCLARATION
num

COUNT

regions

Country

protocol

Protocol

return-type

Format : TXT JSON

lt

Delimiters ( 1:\ r \ n2:/ br 3:\r 4:\n5:\t6:Custom delimiters )

st

Custom delimiters

EXAMPLE

{
    "code" : 0,
    "success": true,
    "msg": "0",
    "request_ip": "request address",
    "data": [
    {"ip": "47.244.192.12","port": 15698}
   ]
}

RESULTS ANNOTATION
code

0 indicates success and I indicates failure

ip

IP

success

True indicates success and false indicates failure

port

port

Authentication account management

Account Name Password Traffic usage limit Traffic consumption Add time Status Remark Operate
    close

    Tips

    After deleting the account, the account password becomes invalid, confirm the deletion?

    Cancel
    Confirm
    close

    Authentication Account

    * Account Name
    * Password
    Traffic limit G
    Remark
    Status

    Disable Enable

    Enable Disabled

    Cancel
    Confirm

    IP White List configuration

    Current IP ***.***.***.***
    + Add White List
    IP Add Time Remark Status Operate

      White List API interface

      Purpose API Link
      Add White List
      Delete White List
      View White List
      close

      Tips

      After deleting the IP, the IP becomes invalid, confirm the deletion?

      Cancel
      Confirm
      close

      Add White List

      * IP Address
      Remark
      Cancel
      Confirm

      Encounter problems? Contact us

      Example

      
      
      
                #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)
            
      
      ABCProxy

      Payment

      Renewal Locations:    US*5 , uk*10     Reselect
      Choose the renewal time:
        Total: $100
        Discount (0% off) $4

        HAVE COUPON CODE ?

        Apply

        Select Your Payment Method

        ABC S5 Proxy Trusted by Thousands of Businesses Since 2018 Ideal for Secure Access to Localized Content and Professional Web Crawling Solutions.

        contact

        Contact us

        Full name

        Required

        Company name

        Company name is required

        Company email address

        Email must be a valid email address

        Phone no.

        ABCProxy +1

        Phone number is required

        ABCProxy will process your data to manage your inquiry and inform you about our services. For more information, visit our Privacy Policy.