Best Residential Proxy IP-Global Residential Proxy Service Provider-360proxy

Première vente d'achat Cliquez pour rejoindre la dernière offre !

360Proxy a d'excellentes performances en termes de fonctions et d'expérience utilisateur, et a été largement reconnu par l'industrie:

Pourquoi choisir 360 proxy

Le premier pool d'agences résidentiels de 80 m et plus au monde a une large option d'intégration sans couture pour étendre votre échelle commerciale.

Utiliser

Couvrant les 190+ pays mondiaux

Cibler tout pays / ville / code postal / FAI

Disponibilité de 99,9 %

Agent résidentiel

Le service d'agence résidentiel le plus rapide de l'industrie, une véritable propriété intellectuelle résidentielle de la source juridique, fournit un plan basé sur GB.

Http (s) + socks5

Emplacement de 190+

Taux de réussite de 99,5%

Apprendre encore plus

Proxy statique

Fournir un large éventail de champs géographiques, de gestion des comptes à long terme et de choix idéaux de commerce électronique.

IP résidentielle réelle

Disponibilité de 99,9 %

Http (s) + socks5

Apprendre encore plus

Une plateforme, Diverses façons d'obtenir l'agence

Utilisateur: certification de mot de passe

Logiciel proxy socks5

Utilisateur: certification de mot de passe

Logiciel proxy socks5

Facile à intégrer et à personnaliser, personnaliser l'emplacement géographique IP, divers exemples de code de langage de programmation communs pour vous assurer que vous pouvez démarrer rapidement.

Applicable aux plans suivants: Agent résidentiel.

: Créer librement les bons de mot de passe

: Facilement intégré au logiciel de troisième partie

: Sessions rotatives et collantes

Utiliser Apprendre encore plus

Langue populaire pour le soutien

Easily integrate our solutions into your business

We ensure that integrating our products into your scraping infrastructure is as easy as possible. With multi-language support and ready-made program demo examples, you're guaranteed to start your data scraping business quickly and easily.

Regardez la documentation

                
  #include iostream
  #include stdio.h
  #include string
  #include Windows.h
  #include "curl/curl.h"
  #pragma comment(lib, "libcurl.lib")
  using namespace std;

  static size_t write_buff_data(char* buffer, size_t size, size_t nitems, void* outstream)
  {//Copy the received data to the cache
  memcpy(outstream, buffer, nitems * size);
  return nitems * size;
  }
  /*
  Use HTTP proxy
  */
  int GetUrlHTTP(char* url, char* buff)
  {
  CURL* curl;
  CURLcode res;
  curl = curl_easy_init();
  if (curl)
  {
      curl_easy_setopt(curl, CURLOPT_PROXY, "http://ip:port");//Set HTTP proxy address
      curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "User name: password");//Proxy username password
      curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set Read-Write Cache
      curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Set Callback Function
      curl_easy_setopt(curl, CURLOPT_URL, url);//Set URL address
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//Sets a long integer to control how many seconds CURLOPT_LOW_SPEED_LIMIT bytes are passed
      curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control how many bytes are transferred
      curl_easy_setopt(curl, CURLOPT_MAX_RECV_SPEED_LARGE, 2000000L);//Maximum download speed

      res = curl_easy_perform(curl);
      curl_easy_cleanup(curl);
      if (res == CURLE_OK) {
          return res;
      }
      else {
          printf("error code:%d\n", res);
          MessageBox(NULL, TEXT("Get IP Error"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
      }
  }
  return res;
  }

              

                                  
  package main

  import (
      "context"
      "fmt"
      "golang.org/x/net/proxy"
      "io/ioutil"
      "net"
      "net/http"
      "net/url"
      "strings"
      "time"
  )
  
  var testApi = "https://api.ipify.org/?format=json"
  
  func main() {
      var proxyIP = ""
      var username = "xxx-zone-isp"
      var password = ""
      httpProxy(proxyIP, username, password)
      time.Sleep(time.Second * 1)
      Socks5Proxy(proxyIP, username, password)
  
  }
  func httpProxy(proxyUrl, user, pass string) {
      defer func() {
          if err := recover(); err != nil {
              fmt.Println(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("http result = ", response.Status, string(body))
  
      return
  }
  
  func Socks5Proxy(proxyUrl, user, pass string) {
  
      defer func() {
          if err := recover(); err != nil {
              fmt.Println(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,
      }
  
      if resp, err := httpClient.Get(testApi); err != nil {
          panic(err)
      } else {
          defer resp.Body.Close()
          body, _ := ioutil.ReadAll(resp.Body)
          fmt.Println("socks5 result = ",string(body))
      }
  }


              

                
  const SocksProxyAgent = require("socks-proxy-agent");
  const net = require("net");
  const proxyHost = "proxy-server-hostname";
  const proxyPort = 1080;
  const proxyUsername = "your-username";
  const proxyPassword = "your-password";
  const agent = new SocksProxyAgent({
  host: proxyHost,
  port: proxyPort,
  auth: `${proxyUsername}:${proxyPassword}`
  });
  const socket = net.connect({
  host: "destination-hostname",
  port: 80,
  agent
  });
  socket.on("connect", () => {
  console.log("Connected to destination server through SOCKS5 proxy.");
  });
  socket.on("error", err => {
  console.error("Error:", err);
  });

              

                
  <?php
  $targetUrl = "https://www.google.com/";
  $proxyServer = "http://";
  $proxyUserPwd = "user:psswd";
  $ch = curl_init();
  curl_setopt($ch, CURLOPT_URL, $targetUrl);
  curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
  curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
  curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
  // curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
  curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
  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);
  curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUserPwd);
  $result = curl_exec($ch);
  $err = curl_error($ch);
  curl_close($ch);
  var_dump($err);
  var_dump($result);
  ?>

              

                
  package demo;
  import okhttp3.Credentials;
  import okhttp3.OkHttpClient;
  import okhttp3.Request;

  import java.io.IOException;
  import java.net.InetSocketAddress;
  import java.net.PasswordAuthentication;
  import java.net.Proxy;

  /**
  * compile 'com.squareup.okhttp3:okhttp:3.10.0'
  */
  class AutProxyJava {
  public static void main(String[] args) throws IOException {
      testWithOkHttp();

      testSocks5WithOkHttp();
  }

  public static void testWithOkHttp() throws IOException {
      String url = "https://api.ipify.org?format=json";
      Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("asg.360s5.com", 3600));
      OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
          String credential = Credentials.basic("username-zone-custom", password);
              return response.request().newBuilder()
          .header("Proxy-Authorization", credential).build();
      }).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 = "https://api.ipify.org?format=json";
      Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("asg.360s5.com", 3600));
      java.net.Authenticator.setDefault(new java.net.Authenticator() {
          private PasswordAuthentication authentication =
          new PasswordAuthentication("laylay-zone-isp", "123456".toCharArray());

          @Override
          protected PasswordAuthentication getPasswordAuthentication() {
              return authentication;
          }
      });
      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);
  }
  }

              

                
  import urllib
  import socks
  import http.client
  from urllib.error import URLError
  import ssl
  from urllib.request import build_opener, HTTPHandler, HTTPSHandler


  def merge_dict(a, b):
  d = a.copy()
  d.update(b)
  return d


  class SocksiPyConnection(http.client.HTTPConnection):
  def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
      self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
      http.client.HTTPConnection.__init__(self, *args, **kwargs)

  def connect(self):
      self.sock = socks.socksocket()
      self.sock.setproxy(*self.proxyargs)
      if type(self.timeout) in (int, float):
          self.sock.settimeout(self.timeout)
      self.sock.connect((self.host, self.port))


  class SocksiPyConnectionS(http.client.HTTPSConnection):
  def __init__(self, proxytype, proxyaddr, proxyport=None, rdns=True, username=None, password=None, *args, **kwargs):
      self.proxyargs = (proxytype, proxyaddr, proxyport, rdns, username, password)
      http.client.HTTPSConnection.__init__(self, *args, **kwargs)

  def connect(self):
      sock = socks.socksocket()
      sock.setproxy(*self.proxyargs)
      if type(self.timeout) in (int, float):
          sock.settimeout(self.timeout)
      sock.connect((self.host, self.port))
      self.sock = ssl.wrap_socket(sock, self.key_file, self.cert_file)


  class SocksiPyHandler(HTTPHandler, HTTPSHandler):
  def __init__(self, *args, **kwargs):
      self.args = args
      self.kw = kwargs
      HTTPHandler.__init__(self)

  def http_open(self, req):
      def build(host, port=None, timeout=0, **kwargs):
          kw = merge_dict(self.kw, kwargs)
          conn = SocksiPyConnection(*self.args, host=host, port=port, timeout=timeout, **kw)
          return conn

      return self.do_open(build, req)

  def https_open(self, req):
      def build(host, port=None, timeout=0, **kwargs):
          kw = merge_dict(self.kw, kwargs)
          conn = SocksiPyConnectionS(*self.args, host=host, port=port, timeout=timeout, **kw)
          return conn

      return self.do_open(build, req)


  username = ""
  password = ""
  ip = "asg.360s5.com"
  port = 3600
  proxy = "socks5://{username}:{password}@{ip}:{port}".format(username=username, password=password, ip=ip, port=port)
  # socks.set_default_proxy(socks.SOCKS5, ip, port,username=username,password=password)
  # socket.socket = socks.socksocket

  url = 'https://www.google.com/'

  try:
  req = urllib.request.Request(url=url, headers={'User-Agent':'Mozilla/5.0 (Windows NT 6.1; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/87.0.4280.88 Safari/537.36'})
  opener = build_opener(SocksiPyHandler(socks.SOCKS5, ip, port, username=username, password=password))
  response = opener.open(req)
  # response = urllib.request.urlopen(req)
  # response = request.urlopen(url)
  print(response.read().decode('utf-8'))
  except URLError as e:
  print(e)

              

C / C ++
Aller
Node.js
Php
JAVA
Python

CroissanceMaison
Piscine de procuration

L'agent 360 sélectionne soigneusement les partenaires de conformité dans l'industrie avec des normes rigoureuses, offrant aux clients des agents résidentiels moraux, plus de 80 millions de pools d'agences résidentiels, couvrant plus de 190 emplacements à travers le monde pour motiver votre industrie.

U.S.

9 489 397 IPS

Brazil

1 246 849 IPS

U.K.

166 431 IPS

Germany

4 982 127 IPS

Turkey

6 633 262 IPS

Hong Kong

119 312 IPS

Australia

2 002 418 IPS

Japon

3 662 712 IPS

Le choix de 360proxy est la meilleure décision pour la protection des données et la vérification publicitaire. L'IP résidentiel fourni non seulement bien en anonymat, mais aussi la stabilité et la vitesse de la connexion sont également satisfaisantes. Il s'agit d'un outil puissant pour notre équipe créative dont nous devons maintenir une position de premier plan dans l'industrie de la publicité, fournissant un soutien plus fiable à nos projets créatifs.

Chant Directeur créatif

Le service d'agence résidentielle de 360proxy fournit un support technique fiable à notre enquête de marché afin de garantir que nos produits ont une aide de données suffisante. Avec des exemples de démonstration de support multi-langues et basés sur le thread, nous pouvons récupérer des données de manière plus rapide et plus précise, ce qui fournit une aide au développement des entreprises!

Gamelle PDG

360Proxy Residential Agency Service fournit un excellent soutien à nos opérations. Son vaste pool de ressources IP couvre de nombreux pays à travers le monde, ce qui nous permet de surveiller plus précisément la surveillance du marché. La stabilité anonyme et la connexion sont les éléments que nous apprécions dans les opérations commerciales. 360proxy a bien fonctionné dans ces deux aspects et est notre partenaire préféré.

Henri Président directeur général