logo








Descripción general
Cómo utilizar
Obtener proxy
Productos
apoderados
  • Plan de proxy residencial (Socks5)
  • Proxies residenciales
  • Proxies residenciales ilimitados
  • Proxies de Datecenter
  • Proxies residenciales estáticos
  • Proxys de ISP
Menú
Mi cuenta
billetera ABC NEW
Intercambio de CDK empresarial
Plan de referencia 10% comisión
Documentación y ayuda
  • Documentación
  • Guía del usuario
  • Vídeotutorial







VIP
Obtener proxy
Autenticación de usuario y contraseña
Extracción de API
Administrador de proxy
Gestión de cuentas de autenticación
Configuración de la lista blanca de IP
Ejemplo

{{userInfo.flow_balance}}G

---

Plan de proxy residencial (tráfico)
Recargar

{{userInfo.static_no_count}} IPs

---

IP disponibles

Plan residencial estático
Recargar

{{farmsDay(userInfo.pack_last_time)}}

---

Horarios disponibles

Plan ilimitado (tráfico)
Recargar

{{userInfo.exclusive_balance}} IPs

---

IP disponibles

Proxies de Datecenter
Recargar

{{userInfo.flow_isp}}G

---

Proxys de ISP
Recargar
Generador de proxy

Selección de grupo de IP de proxy

{{ item.label }}
Seleccione un proxy preciso o conserve el proxy aleatorio posición.

Región

valor del ítem valor del ítem {{ item.label }}
Aquí está tu IP final: PUERTO
Consejos: si se selecciona el valor predeterminado, coincidirá con el servidor en la región donde se encuentra la IP.

Dirección proxy

Seleccione IP

Otros métodos de búsqueda

Sticky: Mantenga la misma dirección IP por hasta 90 minutos con una sesión pegajosa.
Rotar: elija una sesión rotativa para obtener una nueva IP con cada una. pedido.

Modo IP

Duración de la propiedad intelectual (1-120 minutos)

Estado

Ciudad

Puede crear y asignar tráfico a subcuentas mediante usted mismo o utilice directamente su cuenta principal.

Subusuarios

o

Crear usuarios

Nombre de usuario

Contraseña

Comando de prueba

Copiar link

Generar lista de proxy

FORMATO DE PROXY

CANTIDAD

PARÁMETROS DE LA INTERFAZ
zona
obligatorio

Identidad del grupo de proxy

región
No obligatorio

Región, no complete la asignación mixta global predeterminada

calle
No obligatorio

Estado, algunos países lo contienen, por defecto es aleatorio si se deja en blanco

ciudad
No obligatorio

Ciudad, por defecto es aleatoria si se deja en blanco

sesión
No obligatorio

Configuración cuando se requiere una IP fija, definida por el usuario

tiempo de sesión
No obligatorio

Se utiliza junto con una sesión para configurar el tiempo de vencimiento de IP, hasta a 120 minutos

EJEMPLO

zona-ID del grupo de proxy
[cuenta]-zona-abc:[contraseña]
Ejemplo
#rizo -x ***.abcproxy.com:4951 -U "[cuenta]-zona-abc:[contraseña]" ipinfo.io


región-región designada
[cuenta]-zona-abc-región-nosotros:[contraseña]
región-nosotros America
Ejemplo
#rizo -x ***.abcproxy.com:4951 -Udd "[cuenta]-zona-abc-región-nosotros:[contraseña]" ipinfo.io

calle-estado designado
[cuenta]-zona-abc-region-nosotros-California:[contraseña]
santa california California
Ejemplo
#rizo -x ***.abcproxy.com::4951 -Udd "[cuenta]-zona-abc-region-nosotros-California:[contraseña]" ipinfo.io

ciudad-ciudad designada
[cuenta]-zona-abc-region-nos-ciudad-de-california-Nueva York:[contraseña]
ciudad-nuevayorkNueva York
Ejemplo
#rizo -x ***.abcproxy.com:4951 -Udd "[cuenta]-zona-abc-region-nos-ciudad-de-california-Nueva York:[contraseña]" ipinfo.io

sesión-Se corrigió una IP de exportación.
sed para especificar que desea arreglar una IP de salida por un período de tiempo, sin especificar un valor predeterminado de 5 minutos
[cuenta]-zona-abc-region-nos-california-ciudad-nuevayork-sesión-b5b36885:[contraseña]
sesión
Ejemplo
#rizo -x ***.abcproxy.com:4951-Ud.d. "[cuenta]-zona-abc-region-nos-california-ciudad-nuevayork-sesión-b5b36885:[contraseña]" ipinfo.io

SessTime- Especifique una IP de salida con una duración máxima de 120 minutos
Se utiliza con la sesión para especificar una IP de salida fija. Tiempo de vida.
[cuenta]-zona-abc-region-ee-uu-ciudad-de-california-sesión-de-nuevayork-b5b36885-SessTime-120:[contraseña]
SessTime-120 120 mín.
Ejemplo
#rizo -x ***.abcproxy.com:4951-Ud.d. "[cuenta]-zona-abc-region-ee-uu-ciudad-de-california-sesión-de-nuevayork-b5b36885-SessTime-120:[contraseña]" ipinfo.io

Atrás

Lista de proxy

Eliminación por lotes
no recoger elegir Nombre
Fecha de creación, hora
Región
Tipo de sesión
Autenticación mediante inicio de sesión+aprobar
Número
Comportamiento
no recoger elegir {{info.name}}
Editar
Ahorrar
{{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}}
ExportArkansasArkansas
Borrar

{{userInfo.flow_balance}}G

---

Plan de proxy residencial (tráfico)
Recargar

{{userInfo.static_no_count}} IPs

---

IP disponibles

Plan residencial estático
Recargar

{{farmsDay(userInfo.pack_last_time)}}

---

Horarios disponibles

Plan ilimitado (tráfico)
Recargar

{{userInfo.exclusive_balance}} IPs

---

IP disponibles

Proxies de Datecenter
Recargar
Generador de proxy

modelo

Cantidad de extracción

Seleccione región

País País

{{info.label}}

Ver más >

Seleccione región

Seleccione región

Sticky: Mantenga la misma dirección IP en una sesión fija durante 5 minutos.
Rotar: elija una sesión de rotación para obtener una nueva IP para cada solicitud.

modo IP

Otros ajustes

PROTOCOLO

FORMATO

SEPARADOR


Seleccione región

Popular

País País

{{info.label}}

Otros

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

Comando de prueba

DESUCLARACIÓN DE PARÁMETROS API
número

CONTAR

regiones

País

protocolo

Protocolo

tipo de retorno

Formato: TXT JSON

es

Delimitadores ( 1:\ r \ n2:/ hermano 3:\r4:\n5:\t6: delimitadores personalizados )

calle

Delimitadores personalizados

EJEMPLO

{
    "código" : 0,
    "éxito": verdadero,
    "mensaje": "0",
    "pedido_IP": "solicitar dirección",
    "datos": [
    {"IP": "47.244.192.12","puerto": 15698}
   ]
}

ANOTACIÓN DE RESULTADOS
código

0 indica éxito y yo indica fracaso

IP

IP

éxito

Verdadero indica éxito y falso indica fracaso

puerto

puerto

Gestión de cuentas de autenticación

Nombre de la cuenta Contraseña Límite de uso de tráfico Consumo de tráfico Agregar tiempo Estado Observación Funcionar
    cerca

    Consejos

    Después de eliminar la cuenta, la contraseña de la cuenta deja de ser válida, ¿Confirmar la eliminación?

    CancelArkansasArkansas
    ConfirmArkansasArkansas
    cerca

    Cuenta de autenticación

    * Nombre de la cuenta
    * Contraseña
    Límite de tráfico GRAMO
    Observación
    Status

    Disable Enable

    Enable Disabled

    CancelArkansasArkansas
    ConfirmArkansasArkansas

    Configuración de la lista blanca de IP

    IP actual ***.***.***.***
    + Agregar lista blanca
    IP Agregar tiempo Observación estado Funcionar

      Interfaz API de lista blanca

      Objetivo Enlace API
      Agregar lista blanca
      Eliminar lista blanca
      Ver lista blanca
      cerca

      Consejos

      Después de eliminar la IP, la IP deja de ser válida, ¿confirmar la eliminación?

      CancelArkansasArkansas
      Confirmarararar
      cerca

      Agregar lista blanca

      * Dirección IP
      Observación
      CancelArkansasArkansas
      Confirmarararar

      ¿Encontraste problemas? Contáctenos

      Ejemplo

      
      
      
                #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

      Pago

      Ubicaciones de renovación:    tr*5 , Reino Unido*10     Reseleccionar
      Elige el momento de renovación:
        Total: $100
        Descuento (0% apagado) $4

        ¿TIENE CÓDIGO DE CUPÓN?

        Aplicar

        Selecciona tu forma de pago

        Proxy ABC S5 en el que confían miles de empresas desde 2018 Ideal para Acceso seguro a contenido localizado y rastreo web profesional Soluciones.

        contacto

        Contáctenos

        Nombre completo

        Requerido

        Nombre de empresa

        El nombre de la empresa es obligatorio.

        Dirección de correo electrónico de la empresa

        El correo electrónico debe ser una dirección de correo electrónico válida.

        Telefono no.

        ABCProxy +1

        Se requiere número de teléfono

        ABCProxy tratará tus datos para gestionar tu consulta e informarte sobre nuestros servicios. Para más información, visite nuestro Política de privacidad.