Best Residential IP Proxies for Web Scraping & E-commerce

Why 30,000 Users Choose TabProxy's IP Proxy

GDPR & CCPA compliant, with a dedicated Privacy Center

200M+

Ethically-
Sourced IPs

24/7 Tech Support

Country & ZIP code
level targeting

Unlimited threads &
concurrent sessions

200M+ Premium Residential Proxy

TabProxy’s residential proxies offer unparalleled reliability and performance, ideal for data collection, multi-account management, and bypassing geo-restrictions. Benefit from our extensive IP pool covering 195 countries and advanced features. We provide unbeatable value with constantly expanding IP pools, competitive pricing, and continuous service improvements at no extra cost.

 HTTP(s) & SOCKS5 Support

 <0.6s average response time

 99.98% Success Rate

 Rotating and Sticky Sessions

Seamless API Integration

Effortlessly incorporate TabProxy into your systems with our API integration. We ensure integrating our proxies into your infrastructure is smooth and straightforward. With support for multiple languages and ready-to-use code examples, starting your proxy integration project is quick and easy.

     

Choose a coding language


  curl -x ***.tabproxy.vip:5000 -U "customer-USER:PASS"  ipinfo.io


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


  #!/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 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))
        
      }
        
  }


  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);

      }

  }


  #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;
  }

TabProxy provides the best proxy solution
for your use case

Web Scraping

SEO

E-commerce

Social media

Travel and Hotels

Data floodgates open. Unleash scraping with real IPs

Web data is buried deep inside websites, blocked by geofences and bot traps.
Choose ethical residential proxies to ensure a smooth experience for your crawls.

Market Ressarch

Web Scraping

Premium Residential Proxies, Unbeatable Prices

Comprehensive Proxy Solutions for All Your Needs

Residential Proxies

Unlimited Residential Proxies

Static Residential Proxies

Dedicated Datacenter Proxies

Why 30,000 Users Choose TabProxy's IP Proxy

200M+ Premium Residential Proxy

Seamless API Integration

Choose a coding language

TabProxy Solutions for Every Use Case

Top residential proxy locations

TabProxy provides the best proxy solution
for your use case

Data floodgates open. Unleash scraping with real IPs

Improve SERP visibility and enhance your SEO

Monitor competitor pricing and track market trends

Get rid of social media barriers with multi-account management

Explore real-time fares. Gain insight into hotel trends and airfares

Increase your income! Join TabProxy's Affiliate Program

Premium Residential Proxies, Unbeatable Prices

Comprehensive Proxy Solutions for All Your Needs

Residential Proxies

Unlimited Residential Proxies

Static Residential Proxies

Dedicated Datacenter Proxies

Why 30,000 Users Choose TabProxy's IP Proxy

200M+ Premium Residential Proxy

Seamless API Integration

Choose a coding language

TabProxy Solutions for Every Use Case

Top residential proxy locations

TabProxy provides the best proxy solution for your use case

Data floodgates open. Unleash scraping with real IPs

Improve SERP visibility and enhance your SEO

Monitor competitor pricing and track market trends

Get rid of social media barriers with multi-account management

Explore real-time fares. Gain insight into hotel trends and airfares

Increase your income! Join TabProxy's Affiliate Program

TabProxy provides the best proxy solution
for your use case