logotipo








Visão geral
Como usar
Obtenha proxy
Produtos
Proxies
  • Plano de Proxy Residencial (Socks5)
  • Proxies Residenciais
  • Proxies residenciais ilimitados
  • Proxies Dedicados de Datacenter
  • Proxies residenciais estáticos
  • Proxies ISP rotativos
Cardápio
Minha conta
Carteira ABC NEW
Troca empresarial de CDK
Plano de referência 10% comissão
Documentação e ajuda
  • Documentação
  • Guia de usuario
  • Vídeo tutorial







VIP
Obtenha proxy
Autenticação de usuário e senha
Extração de API
Gerenciador de proxy
Gerenciamento de conta de autenticação
Configuração da lista branca de IP
Exemplo

{{userInfo.flow_balance}}G

---

Plano de proxy residencial(Tráfego)
Recarrega

{{userInfo.static_no_count}} IPs

---

IPs disponíveis

Plano Residencial Estático
Recarrega

{{farmsDay(userInfo.pack_last_time)}}

---

Horários disponíveis

Plano Ilimitado(Tráfego)
Recarrega

{{userInfo.exclusive_balance}} IPs

---

IPs disponíveis

Proxies Dedicados de Datacenter
Recarrega

{{userInfo.flow_isp}}G

---

Proxies ISP rotativos
Recarrega
Gerador de proxy

Seleção de pool de IP proxy

{{ item.label }}
Selecione um proxy preciso ou mantenha o proxy aleatório posição.

Região

valor do item valor do item {{ item.label }}
Aqui está seu IP final:PORT
Dicas: Se o padrão for selecionado, ele corresponderá ao servidor em a região onde o IP está localizado.

Endereço proxy

Selecione IP

Outros métodos de pesquisa

Fixo:Mantenha o mesmo endereço IP por até 90 minutos com uma sessão pegajosa.
Girar:Escolha uma sessão rotativa para obter um novo IP a cada solicitar.

Modo IP

Duração do IP (1-120 minutos)

Estado

Cidade

Você pode criar e alocar tráfego para subcontas você mesmo ou use diretamente sua conta principal.

Subusuários

ou

Criar usuários

Nome de usuário

Senha

Comando de teste

Link de cópia

Gerar lista de proxy

FORMATO PROXY

QUANTIDADE

PARÂMETROS DE INTERFACE
zona
obrigatório

Identidade do pool de proxy

região
Não mandatório

Região, não preencha a alocação mista global padrão

st
Não mandatório

Estado, alguns países contêm, o padrão é aleatório se deixado em branco

cidade
Não mandatório

Cidade, padrão aleatório se deixado em branco

sessão
Não mandatório

Configuração quando é necessário um IP fixo, definido pelo usuário

SessTime
Não mandatório

Usado em conjunto com uma sessão para configurar o tempo de envelhecimento do IP, até a 120 minutos

EXEMPLO

zona-ID do pool de proxy
[conta]-zona-abc:[senha]
Exemplo
#enrolar -x ***.abcproxy. com:4951 -VOCÊ "[conta]-zona-abc:[senha]" ipinfo.io


região-região designada
[conta]-zona-abc-região-nós:[senha]
região-nós América
Exemplo
#enrolar -x ***.abcproxy. com:4951 -você "[conta]-zona-abc-região-nós:[senha]" ipinfo.io

st-estado designado
[conta]-zona-abc-região-us-Califórnia:[senha]
Santa Califórnia Califórnia
Exemplo
#enrolar -x ***.abcproxy.com::4951 -você "[conta]-zona-abc-região-us-Califórnia:[senha]" ipinfo.io

cidade-cidade designada
[conta]-zona-abc-região-us-california-city-Nova Iorque:[senha]
cidade-nova yorkNova Iorque
Exemplo
#enrolar -x ***.abcproxy. com:4951 -você "[conta]-zona-abc-região-us-california-city-Nova Iorque:[senha]" ipinfo.io

sessão-Corrigido um IP de exportação
sed para especificar que você deseja corrigir um IP de saída por um período de tempo, sem especificar um padrão de 5 minutos
[conta]-zona-abc-região-us-california-city-newyork-sessão-b5b36885:[senha]
sessão
Exemplo
#enrolar -x ***.abcproxy. com:4951-você "[conta]-zona-abc-região-us-california-city-newyork-sessão-b5b36885:[senha]" ipinfo.io

SessTime- Especifique um IP de saída com duração máxima de 120 minutos
Usado com sessão para especificar um IP de saída fixo Tempo de vida
[conta]-zona-abc-região-us-california-city-newyork-session-b5b36885-SessTime-120:[senha]
SessTime-120 120 min
Exemplo
#enrolar -x ***.abcproxy. com:4951-você "[conta]-zona-abc-região-us-california-city-newyork-session-b5b36885-SessTime-120:[senha]" ipinfo.io

Voltar

Lista de proxy

Exclusão em lote
não escolha escolha Nome
Data de criação, hora
Região
Tipo de sessão
Autenticação por login+passarar
Número
Ações
não escolha escolha {{info.name}}
Editar
Salvar
{{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}}
Exportarar
Excluir

{{userInfo.flow_balance}}G

---

Plano de proxy residencial(Tráfego)
Recarrega

{{userInfo.static_no_count}} IPs

---

IPs disponíveis

Plano Residencial Estático
Recarrega

{{farmsDay(userInfo.pack_last_time)}}

---

Horários disponíveis

Plano Ilimitado(Tráfego)
Recarrega

{{userInfo.exclusive_balance}} IPs

---

IPs disponíveis

Proxies Dedicados de Datacenter
Recarrega
Gerador de proxy

modelo

Quantidade de extração

Selecione a região

País País

{{info.label}}

Veja mais >

Selecione a região

Selecione a região

Fixo: mantenha o mesmo endereço IP em uma sessão fixa por 5 minutos.
Rotacionar: Escolha uma sessão de rotação para obter um novo IP para cada solicitação.

Modo IP

Outros ajustes

PROTOCOLO

FORMATAR

SEPARADOR


Selecione a região

Popular

País País

{{info.label}}

Outros

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

Comando de teste

DSUCLARAÇÃO DO PARÂMETRO API
número

CONTAR

regiões

País

protocolo

Protocolo

tipo de retorno

Formato: TXT JSON

isso

Delimitadores ( 1:\ R \ n2:/ bR 3:\R 4:\n5:\t6: Delimitadores personalizados )

st

Delimitadores personalizados

EXEMPLO

{
    "código" : 0,
    "sucesso": verdadeiro,
    "mensagem": "0",
    "solicitar_ip": "solicitar endereço",
    "dados": [
    {"ip": "47.244.192.12","porta": 15698}
   ]
}

ANOTAÇÃO DE RESULTADOS
código

0 indica sucesso e I indica fracasso

IP

PI

sucesso

Verdadeiro indica sucesso e falso indica falha

portaa

portaa

Gerenciamento de conta de autenticação

Nome da conta Senha Limite de uso de tráfego Consumo de tráfego Tempo extra Status Observação Operar
    fechar

    Pontas

    Depois de excluir a conta, a senha da conta torna-se inválida, confirmar a exclusão?

    Cancelarar
    confirme
    fechar

    Conta de autenticação

    * Nome da conta
    * Senha
    Limite de tráfego G
    Observação
    Status

    Disable Enable

    Enable Disabled

    Cancelarar
    confirme

    Configuração da lista branca de IP

    IP atual ***.***.***.***
    + Adicionar lista branca
    PI Tempo extra Observação estado Operar

      Interface API da Lista Branca

      Propósito Link da API
      Adicionar lista branca
      Excluir lista branca
      Ver lista branca
      fechar

      Pontas

      Após excluir o IP, o IP torna-se inválido, confirmar a exclusão?

      Cancelarar
      confirme
      fechar

      Adicionar lista branca

      * Endereço de IP
      Observação
      Cancelarar
      confirme

      Encontrou problemas? Contate-nos

      Exemplo

      
      
      
                #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

      Pagamento

      Locais de renovação:    NÓS*5 , Reino Unido*10     Selecionar novamente
      Escolha o horário de renovação:
        Total: $100
        Desconto (0% desligado) $4

        TEM CÓDIGO DE CUPOM?

        Aplicar

        Selecione seu metodo de pagamento

        ABC S5 Proxy Confiado por Milhares de Empresas Desde 2018 Ideal para Acesso Seguro a Conteúdo Localizado e Soluções Profissionais de Raspagem Web.

        contact

        Contate-nos

        Nome completo

        Obrigatório

        Nome da empresa

        Nome da empresa é obrigatório

        Endereço de e-mail da empresa

        E-mail deve ser um endereço de e-mail válido

        Nº de telefone.

        ABCProxy +1

        Número de telefone é obrigatório

        ABC .io processará seus dados para gerenciar sua consulta e informá-lo sobre nossos serviços. Para mais informações, visite nossa Política de Privacidade.