first-screen-bg first-screen-bg

Trusted IPs, Unlimited Access

Industry-leading ethical proxy networks, empowering boundless data access with precision, stability, and trust.

custom-hero-bg

35M+ Proxy Pool

99.9% Success Rate

<0.5s Response Time

Unlimited Threads

HTTP & SOCKS5

Proxies that meet all your needs

Supporting your network data projects

Rotating Residential Proxy

Rotating Residential Proxy

Access 35M+ residential IPs with automatic rotation for seamless web scraping and data extraction.

  • check 35M+ Residential IPs
  • check Country/State Targeting
  • check Unlimited Concurrent Sessions
  • check Sticky/Rotating Options
Rotating Residential Proxy
Static Residential Proxy

Unlimited Residential Proxy

Global dynamic IP pool with unlimited traffic usage, supporting sticky and rotating options for high-performance connections.

  • check No traffic limits
  • check Global Random
  • check Dedicated Servers
  • check Custom Bandwidth
Static Residential Proxy

Static Residential Proxy

Dedicated IPs with long-term stability, ideal for e-commerce, social media, and secure browsing.

  • check Real Residential IPs
  • check 100% Dedicated
  • check High Availability
  • check Up to 90-day Lease
Rotating Residential Proxy

High-Quality Global Proxy Pool

Leverage industry-leading proxy services for seamless access to public data with stability and reliability.

United States

United States

1,578,420 IPs

United Kingdom

United Kingdom

538,330 IPs

Germany

Germany

442,145 IPs

Canada

Canada

296,370 IPs

Brazil

Brazil

949,015 IPs

Australia

Australia

426,730 IPs

35M+
Residential IPs
195+
Countries/Regions
99.8%
IP Purity

Efficient, Smart, Seamless Connection – Your Ideal Proxy Solution

easily High Compatibility

Easily Integrate with Any Tool

Supports various API interfaces and development tools for quick integration into your existing system, with no complex configuration required, saving both time and costs.

Get Started Now
bg

                            
    #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)
        {
       
            // api http
            curl_easy_setopt(curl, CURLOPT_PROXY, "http://156.229.21.94:1000");
            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("%d", res);
            }
        }
        return res;
    }

    int GetUrlSocks5(char *url, char *buff)
    {
        CURL *curl;
        CURLcode res;
        curl = curl_easy_init();
        if (curl)
        {
            // api socks5
            curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://156.229.21.94:1000");
            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("%d", res);
            }
        }
        return res;
    }

    int main()
    {
        char *buff = (char *)malloc(1024 * 1024);
        memset(buff, 0, 1024 * 1024);
        GetUrlHTTP("http://ipinfo.io/json", buff);
        printf("response: %s", buff);
        memset(buff, 0, 1024 * 1024);
        GetUrlSocks5("http://ipinfo.io/json", buff);
        printf("response: %s", buff);
        free(buff);
        Sleep(10 * 1000);
        return 0;
    }


    package main

    import (
    	"log"

    	"github.com/go-resty/resty/v2"
    )

    func main() {
    	// api socks5
    	client := resty.New()
    	client.SetProxy("socks5://156.229.21.94:1000")
    	response, err := client.R().Get("http://ipinfo.io/json")
    	if err != nil {
    		panic(err)
    	}
    	log.Println(string(response.Body()))

    	// api http
    	client = resty.New()
    	client.SetProxy("http://156.229.21.94:1000")
    	response, err = client.R().Get("http://ipinfo.io/json")
    	if err != nil {
    		panic(err)
    	}
    	log.Println(string(response.Body()))
    }

          


    // api http
    require("request-promise")({
      url: "http://ipinfo.io/json",
      proxy: "http://156.229.21.94:1000",
    }).then(
      function (data) {
        console.log(data);
      },
      function (err) {
        console.error(err);
      }
    );
        

    <?php
    // SOCKS5 proxy configuration (NO AUTH)
    $proxyHost = '156.229.21.94'; // Proxy host
    $proxyPort = '1000'; // Proxy port

    // IP info URL
    $ipInfoUrl = 'https://ipinfo.io/json';

    // Initialize cURL
    $ch = curl_init();

    // Set cURL options
    curl_setopt($ch, CURLOPT_URL, $ipInfoUrl); // URL to request
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true); // Return the response as a string
    curl_setopt($ch, CURLOPT_PROXY, $proxyHost . ':' . $proxyPort); // Set the SOCKS5 proxy
    curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_SOCKS5_HOSTNAME); // Set proxy type as SOCKS5 and resolve DNS through proxy
    curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false); // Disable SSL peer verification
    curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, false); // Disable SSL host verification
    curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 30); // 30-second connection timeout
    curl_setopt($ch, CURLOPT_TIMEOUT, 60); // 60-second total timeout
    curl_setopt($ch, CURLOPT_VERBOSE, true); // Enable verbose logging for debugging

    // Execute the request
    $response = curl_exec($ch);

    // Check for cURL errors
    if ($response === false) {
        echo "cURL Error: " . curl_error($ch) . "";
    } else {
        echo "Response from IP info:";
        echo $response;
    }

    // Close the cURL session
    curl_close($ch);
          
?>


    import java.net.*;
    import java.net.http.*;
    import java.time.Duration;

    public class HttpClientSocksNoAuth {
        public static void main(String[] args) throws Exception {
            HttpClient client = HttpClient.newBuilder()
                .proxy(ProxySelector.of(
                    new InetSocketAddress("156.229.21.94", 1000) // Set the proxy server address and port you extracted
                ))
                .connectTimeout(Duration.ofSeconds(10))
                .build();

            HttpRequest req = HttpRequest.newBuilder()
                .uri(URI.create("https://ipinfo.io/json"))
                .timeout(Duration.ofSeconds(10))
                .header("User-Agent", "Mozilla/5.0")
                .GET()
                .build();

            HttpResponse resp =
                client.send(req, HttpResponse.BodyHandlers.ofString());
            if (resp.statusCode() == 200) {
                System.out.println(resp.body());
            } else {
                System.err.println("HTTP error: " + resp.statusCode());
            }
        }
    }
          

    # api socks5
    import requests

    response = requests.get(
        "http://ipinfo.io/",
        proxies={
            "http": "socks5://156.229.21.94:1000",
            "https": "socks5://156.229.21.94:1000",
        },
    )
    print(response.text)

    # api http

    import requests

    response = requests.get(
        "http://ipinfo.io/",
        proxies={
            "http": "http://156.229.21.94:1000",
            "https": "http://156.229.21.94:1000",
        },
    )
    print(response.text)

           
IP Resource Management Dashboard

Flexible IP Resource Management

Easily create and manage proxy users, set IP whitelists. Enable real-time traffic management, usage tracking, and instant adjustments for optimal performance.

powerful Powerful dashboard
powerful Monitor proxy usage in real-time
Explore Dashboard
Ethical Proxy Network

Ethical Proxy Network

Global trusted IP resources ensure your data collection is legal and efficient.

Worry-Free Customer Support

Worry-Free Customer Support

Professional support with fast response to resolve your concerns.

Industry-Recognized Preferred Solution

Flexible Resale and Distribution

Easily integrate and resell our high-quality proxy services to your clients.

How Customers Use Our Proxies

Easily integrate our proxy service to quickly access global IP resources, meeting various business needs.

Data Scraping

Data Scraping

Efficiently collect accurate analysis data from any website

Learn more Learn more
Market Research

Market Research

Scrape web trends and analysis data through proxies

Learn more Learn more
Ad Verification

Ad Verification

Monitor and evaluate ad performance from different locations

Learn more Learn more
Social Media

Social Media

Social media account management, anonymous browsing, and scraping

Learn more Learn more
E-commerce

E-commerce

Accurately collect and monitor data from global e-commerce platforms

Learn more Learn more
Travel Aggregation

Travel Aggregation

Instantly track updated flight and hotel deals on various platforms

Learn more Learn more

Why Professionals Choose Us