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

New Residential Proxies Plan, only

$16.5! Act now

360Proxy has excellent performance in terms of functions and user experience, and is widely recognized by the industry:

Why choose 360Proxy

The world's leading 80M+ residential proxy pool, wide range of seamless

Try now

integration options to scale your business.

Target any country, city, zip code, ISP

99.9% uptime

Unlimited Residential Proxies

The fastest residential proxy service in the industry, real residential IPs from legal sources, billed based on traffic.

Unlimited usage of traffic

Unlimited use of IP

More than 50 regions around the world

Learn more

Static Residential Proxies

Offers a wide range of geographical locations, ideal for long-term account management and e-commerce.

Real residential IP

99.9% uptime

Unlimited usage of traffic

Learn more

A platform, multiple ways to obtain proxies

Username: Password

Whitelist

The functionality of whitelist enables you to build preset configurations and associate them with lPs.Using whitelist to manage IPs enhances the convenience of access while maintaining the security and specificity of proxy settings.

Easy to integrate and customize, custom IP geographical location, and various common programming language code examples to ensure you can get started quickly.

Applies to the following plans: Residential Proxies.

: Freely create password credentials

: Easy integration with third-party software

: Rotation and sticky sessions

Try now Learn more

Supported popular languages

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, starting your data scraping business is guaranteed to be quick and easy.

View document

                
  #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++
Go
Node.js
Php
JAVA
Python

GrowingResidential
proxies pool

360Proxy uses strict standards to carefully select compliant partners in the industry to provide customers with ethically sourced residential proxies. With a pool of more than 80 million residential proxies, covering more than 190 locations around the world, we provide services for your industry power.

United States

9,489,397 IPs

Brazil

1,246,849 IPs

166,431 IPs

Germany

4,982,127 IPs

Türkiye

6,633,262 IPs

Hong Kong

119,312 IPs

Australia

2,002,418 IPs

Japan

3,662,712 IPs

Choosing 360Proxy is the best decision for our data protection and advertising verification. The residential IP it provides not only performs well in anonymity, but the stability and speed of the connection are also satisfactory. This is ideal for what we need in advertising It is a powerful tool for creative teams that remain at the forefront of the industry and provides more reliable support for our creative projects.

Carol Creative Director

360Proxy's residential proxy service provides reliable technical support for our market research and ensures that our products receive sufficient data help. With multi-language support and threaded program demo examples, we can do it faster and A more accurate way to capture data helps business development!

Billy CEO

360Proxy residential proxy service provides excellent support for our operations. Its extensive IP resource pool covers multiple countries around the world, allowing us to conduct market monitoring more accurately. Anonymity and connection stability are key to our elements that are very important in business operations, 360Proxy has performed well in both aspects and is our preferred partner.

Henry COO