Coupon available:
HALLOWEEN2024 copy
Email
Enterprise Service
menu
Email
Enterprise Service
Submit
Basic information
Waiting for a reply
Your form has been submitted. We'll contact you in 24 hours.
Close

Multiple proxy solutions

Various types of proxies facilitate your online business, get data with market-leading proxy service.
Rotating Proxies
Static Proxies
Socks5 Proxies
Rotating Residential Proxies
Rotating Residential Proxies
Best proxies for web-scraping, lower IP blocking rate.
Starts from
$0.77/GB
Unlimited Residential Proxies
Unlimited Residential Proxiess
Residential proxies with unlimited traffic usage.
Starts from
$79/DAY
Rotating Datacenter Proxies
Rotating Datacenter Proxies
Fast and stable proxies with reliable datacenters.
Starts from
$0.77/GB
Rotating ISP Proxies
Rotating ISP Proxies
Get the best of both residential and datacenter proxies.
Starts from
$0.77/GB
STATIC ISP PROXIES
Static ISP Proxies
High-quality ISP proxies from reliable ISPs.
Starts from
$5/Month
DEDICATED DC PROXIES
Dedicated Datacenter Proxies
Stable datacenter IPs with high uptime.
Starts from
$2.5/IP
S5 PROXIES
Socks5 Residential Proxies
Residential Proxies charged by IP amount.
Starts from
$0.045/IP
Learn more about Rotating Proxies
Learn more about Static Proxies
Learn more about Socks5 Proxies

PYPROXY Advantages

High-quality IP resources and professional service makes PYPROXY a popular proxy service provider.
Fast and Stable Connection
Fast and Stable
Connection
Advanced technology and high-quality resources guarantee your proxy network connection.
Self-built IP Pool
PYPROXY self-built IP pool provides high-quality proxies, which we can take full advantage of.
Premium Proxy Server
Customized and dedicated proxy servers make it 99.9% uptime and stable connection.
Fast and Stable Connection
Various Proxy
Features
Enjoy the convenient proxy using and management. Adjust the proxy flexibly as you wish.
Unlimited Concurrency
No limit on threads or sessions. Support bulk proxy generating. Maximum your business potential.
Sub-account Management
Create sub-accounts to manage your traffic usage or share your proxies with your partners.
Fast and Stable Connection
Improve Your
Productivity
Get access to high-quality PYPROXY IP pool to boost your business.
Safe and Highly-anonymous
Highly-anonymous proxies hide your real IP and unlock content and data of various websites worldwide.
Constantly updated IP resources
We keep looking for high-quality IP resources and upgrade our IP pool to satisfy more customers'needs.

Integrate PYPROXY to various programming languages

Our proxies are compatible with all kinds of proxy softwares, as well as popular programming languages. With code samples on our site, you can start scrap web data quickly and easily.
Whitelist Auth
User & Pass Auth
													
// demo.cpp : Define the entrance for the console application.
//

#include "stdafx.h"
#include "curl/curl.h"
#pragma comment(lib, "libcurl.lib")

//Under the CURLOPT_WRITEFUNCTION setting property, use the callback write_buff_data for processing
static size_t write_buff_data(char *buffer, size_t size, size_t nitems, void *outstream)
{
	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://proxy host:port");//Set proxy
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//void* buff will be passed to the fourth parameter of the callback function write_buff_data void* outstream
		curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//Under the CURLOPT_WRITEFUNCTION setting property, use the callback write_buff_data for processing
		curl_easy_setopt(curl, CURLOPT_URL, url);//Set domain to visit
		/* Abort if speed drops below 50 bytes/second for 10 seconds */
		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);/*Highest 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("Error in getting IP"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
		}
	}
	return res;
}
/*
Use socks5 proxy
*/
int GetUrlSocks5(char *url, char *buff)
{
	CURL *curl;
	CURLcode res;
	curl = curl_easy_init();
	if (curl)
	{
		curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://Proxy host:port");//Set proxy
		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);/*Highest 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("Error in getting IP"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
		}
	}
	return res;
}
/*
Not use proxy
*/
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);/*Highest 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("Error in getting IP"), TEXT("assistant"), MB_ICONINFORMATION | MB_YESNO);
		}
	}
	return res;
}
int main()
{
	char *buff=(char*)malloc(1024*1024);
	memset(buff, 0, 1024 * 1024);

	GetUrl("http://baidu.com", buff);
	printf("Not use proxy:%s\n", buff);

	memset(buff, 0, 1024 * 1024);
	GetUrlHTTP("http://baidu.com", buff);
	printf("result of http:%s\n", buff);

	memset(buff, 0,1024 * 1024);
	GetUrlSocks5("http://baidu.com", buff);
	printf("result of socks5:%s\n", buff);

	free(buff);
	Sleep(10 * 1000);//Wait 10 seconds to exit
	
	return 0;
}																																					
												
													
package main

import (
	"context"
	"fmt"
	"io/ioutil"
	"net"
	"net/http"
	"net/url"
	"strings"
	"time"

	"golang.org/x/net/proxy"
)

// Proxy setting
var ip = "proxy server"   //Example:192.168.0.1
var port = "port" //Example:2333
// Proxy server
var proxyServer = "http://" + ip + ":" + port

// Test link
var testApi = "https://ipinfo.pyproxy.io"

func main() {
	var proxyIP = proxyServer
	go httpProxy(proxyIP, "", "")
	go Socks5Proxy(proxyIP, "", "")
	time.Sleep(time.Minute)
}

// 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", "response:", 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]", "response:", 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, "response:", 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(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[socks5 success]", "response:", string(body))
	}
}														
												
													
#!/usr/bin/env node
require('request-promise')({
	url: 'https://pyproxy.com',//Request URL
	proxy: 'http://ip:port',//Proxy server IP: port
	})
.then(function(data){ console.log(data); },
	function(err){ console.error(err); });													
												
													
<?php
//Proxy setting
$ip = "Proxy server IP";//Example:192.168.0.1
$port = "Port";//Example:2333
// Target URL
$targetUrl = "http://google.com";
// Proxy server
$proxyServer = "http://$ip:$port";
													
// Tunnel verification
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $targetUrl);
curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
													
// Proxy server setting
curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
// curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
													
// Tunnel verification setting
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:4.9.3'
 */
class ApiProxyJava {
	public static void main(String[] args) throws IOException {
		testHttpWithOkHttp();
		testSocks5WithOkHttp();
	}

	/**
	 * http proxy
	 */
	public static void testHttpWithOkHttp() throws IOException {
		//Set the URL you want to visit
		String url = "https://ipinfo.pyproxy.io";
		//Create an HTTP proxy object and set IP and port for the proxy server
		Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
		//Build an OkHttpClient instance and configure the HTTP proxy
		OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
		//Send GET Request and get response
		Request request = new Request.Builder().url(url).build();
		okhttp3.Response response = client.newCall(request).execute();
		//Get and print response
		String responseString = response.body().string();
		System.out.println(responseString);
	}

	/**
	 * SOCKS5 Proxy
	 */
	public static void testSocks5WithOkHttp() throws IOException {
		//Set the URL you want to visit
		String url = "https://ipinfo.pyproxy.io";
		//Create a SOCKS proxy object and set IP and port for the proxy server
		Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("ip", "port"));//The "ip" and "port" here should be replaced with proxy server IP and port.
		//Build an OkHttpClient instance and configure the SOCKS proxy
		//A SOCKS proxy is used here, which means that all network traffic (including TCP connections) will be forwarded through this SOCKS proxy.
		OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
		//Send GET Request and get response
		Request request = new Request.Builder().url(url).build();
		okhttp3.Response response = client.newCall(request).execute();
		//Get and print response
		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

# Set head of request
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"
}
# Test URL
testUrl = 'https://ipinfo.pyproxy.io'


# Main business
def testPost(host, port):
	# Configure IP and port you get
	proxies = {
		# Proxy server IP you get by API
		# Port you get by API
		'http': 'http://{}:{}'.format(host, port),
		'https': 'http://{}:{}'.format(host, port),
	}
	while True:
		try:
			# Test after configuring proxies
			res = rq.get(testUrl, proxies=proxies, timeout=5)
			# print(res.status_code)
			# Print the result of request
			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)


# Link for getting proxies  Return is in json type
tiqu = 'Get proxy link'

while 1 == 1:
	# Get 10 at a time, and put in thread
	resp = rq.get(url=tiqu, timeout=5)
	try:
		if resp.status_code == 200:
			dataBean = json.loads(resp.text)
		else:
			print("Fail to get")
			time.sleep(1)
			continue
	except ValueError:
		print("fail to get")
		time.sleep(1)
		continue
	else:
		# Parse json array and get ip and port
		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:  # Turn on thread
				t.start()
				time.sleep(0.01)
			for t in threads:  # Block thread
				t.join()
	# break
	time.sleep(1)

													
												
C/C++
GO
Node.js
PHP
Java
Python
													
// demo.cpp : Define the entry point of a console application
//

#include "stdafx.h"
#include "curl/curl.h"
#pragma comment(lib, "libcurl.lib")

//cURL callback function
static size_t write_buff_data(char *buffer, size_t size, size_t nitems, void *outstream)

/*
Use an 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://proxy server:port");//Set the HTTP proxy address								
		curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "username:password");//username and password, separated by ":"
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set read/write buffers
		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);//Set a long integer to control the number of seconds to transfer the bytes defined by CURLOPT_LOW_SPEED_LIMIT
		curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control the number of bytes to transfer						
		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("Helper"), MB_ICONINFORMATION | MB_YESNO);	
		}
	}
	return res;
}
/*
Use a SOCKS5 proxy
*/
int GetUrlSocks5(char *url, char *buff)
{
	CURL *curl;
	CURLcode res;
	curl = curl_easy_init();
	if (curl)
	{
		curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://proxy server:port");//Set the SOCKS5 proxy address												
		curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "username:password");//username and password, separated by ":"														
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set read/write buffers
		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);//Set a long integer to control the number of seconds to transfer the bytes defined by CURLOPT_LOW_SPEED_LIMIT
		curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control the number of bytes to transfer
		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("Helper"), MB_ICONINFORMATION | MB_YESNO);					
		}
	}
	return res;
}
/*
Don't use a proxy
*/
int GetUrl(char *url, char *buff)
{
	CURL *curl;
	CURLcode res;
	//The cURL library used, initialize the cURL library
	curl = curl_easy_init();
	if (curl)
	{
		curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//Set read/write buffers							
		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);//Set a long integer to control the number of seconds to transfer the bytes defined by CURLOPT_LOW_SPEED_LIMIT							
		curl_easy_setopt(curl, CURLOPT_LOW_SPEED_LIMIT, 50L);//Set a long integer to control the number of bytes to transfer
		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("Helper"), MB_ICONINFORMATION | MB_YESNO);						
		}
	}
	return res;
}
int main()
{
	char *buff=(char*)malloc(1024*1024);
	memset(buff, 0, 1024 * 1024);
	//Not use an HTTP proxy
	GetUrl("http://myip.top", buff);
	printf("Not use proxy:%s\n", buff);
	//Use an HTTP proxy
	memset(buff, 0, 1024 * 1024);
	GetUrlHTTP("http://ipinfo.io", buff);
	printf("HTTP result:%s\n", buff);
		
	//Use a SOCKS5 proxy
	memset(buff, 0,1024 * 1024);
	GetUrlSocks5("http://ipinfo.io", buff);
	printf("SOCKS5 result:%s\n", buff);
	free(buff);
	Sleep(10 * 1000);//Wait 10 seconds and exit
			
	
	return 0;
}																											
												
													
package main

import (
  "context"
  "fmt"
  "io/ioutil"
  "net"
  "net/http"
  "net/url"
  "strings"
  "time"

  "golang.org/x/net/proxy"
)

// User Pass Auth Setting
var account = "Proxy username"
var password = "Proxy password"

// Proxy server
var proxyServer = "proxy address"  //Example:xxx.na.pyproxy.io:2336;

// Test URL
var testApi = "https://ipinfo.pyproxy.io"

func main() {
  go httpProxy(proxyServer, account, password)
  go Socks5Proxy(proxyServer, account, password)

  time.Sleep(time.Minute)
}

// 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", "response:", 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]", "response:", 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, "response:", 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(time.Now().Format("2006-01-02 15:04:05 07"), proxyUrl, "[socks5 success]", "response:", string(body))
  }
}
													
												
													
#!/usr/bin/env node
require('request-promise')({
	url: 'https://ipinfo.io',//Request URL
	proxy: 'http://???-zone-custom:????@pyproxy.com',//proxy username-zone-proxy pool:proxy username@proxy server address
	})
.then(function(data){ console.log(data); },
	function(err){ console.error(err); });
													
												
													
<?php
//User Pass Auth setting
$user = "Proxy_username";
$password = "Proxy_password";
// Target URL
$targetUrl = "http://google.com";
// Proxy server
$proxyServer = "proxy address";  //Example:xxx.na.pyproxy.io:2336;
$proxyUserPwd = "$user:$password";
		
// Tunnel verification
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $targetUrl);
curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
		
// Set 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);
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:4.9.3'
 */
class AutProxyJava {
	public static void main(String[] args) throws IOException {
		testWithOkHttp();

		testSocks5WithOkHttp();
	}

	/**
	 * http代理(http proxy)
	 */
	public static void testWithOkHttp() throws IOException {
		String url = "https://ipinfo.pyproxy.io";//Request URL
		//Create a proxy object of type HTTP and specify the host name and port number of the proxy server
		Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("host", "port"));//The "host" and "port" used here should be replaced with the proxy server address and port.
		// proxyAuthenticator):(Build a custom OkHttpClient instance, set up a proxy server and add a proxy authenticator (proxyAuthenticator)
		OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
			// Generate the credential string for Basic authentication here)
			String credential = Credentials.basic("account", "password");//The "account" and "port" here should be replaced with proxy username and proxy password.
			// If proxy server needs authentication, please add authentication information in request head.)
			return response.request().newBuilder()
					.header("Proxy-Authorization", credential)
					.build();
		}).build();

		//Send GET Request and get response
		Request request = new Request.Builder().url(url).build();
		okhttp3.Response response = client.newCall(request).execute();
		//Get and print response
		String responseString = response.body().string();
		System.out.println(responseString);
	}

	/**
	 * Socks5 proxy
	 */
	public static void testSocks5WithOkHttp() throws IOException {
		//Request URL
		String url = "https://ipinfo.pyproxy.io";
		//Create a SOCKS proxy object and set the actual proxy server host name and port
		Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("host", "port"));//The "host" and "port" used here should be replaced with the proxy server address and port.
		//Set the global default authenticator (Authenticator) to handle basic authentication required for all network connections. A username and password are preset here
		java.net.Authenticator.setDefault(new java.net.Authenticator() {
			private PasswordAuthentication authentication =
					new PasswordAuthentication("account", "password".toCharArray());//The "account" and "port" here should be replaced with proxy username and proxy password.

			@Override
			protected PasswordAuthentication getPasswordAuthentication() 
		});
		//Build an OkHttpClient instance and configure the SOCKS proxy
		OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
		//Send GET request and get response
		Request request = new Request.Builder().url(url).build();
		okhttp3.Response response = client.newCall(request).execute();
		//Get and print response
		String responseString = response.body().string();
		System.out.println(responseString);
	}
}

													
												
													
'''
Import thread, time and request package
to realize multiple thread control, waiting and http request
'''
import _thread
import time
import requests

# Set request head
headers = {
	"Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8",
	"User-Agent": "Mozilla/5.0 (iPhone; CPU iPhone OS 10_3_3 like Mac OS X) AppleWebKit/603.3.8 (KHTML, like Gecko) Mobile/14G60 MicroMessenger/6.5.19 NetType/4G Language/zh_TW",
}

# Test URL
mainUrl = 'https://ipinfo.pyproxy.io'

def testUrl():
	# Set proxy username and password
	proxy = {
		'http': 'http://proxy username:proxy password@proxy server IP:proxy server port',
		'https': 'http://proxy username:proxy password@proxy server IP:proxy server port',
	}
	try:
		res = requests.get(mainUrl, headers=headers, proxies=proxy, timeout=10)
		print(res.status_code, res.text)
	except Exception as e:
		print("Fail to visit", e)
		pass

# Turn on 10 threads to test
for i in range(0, 10):
	_thread.start_new_thread(testUrl, ())
	time.sleep(0.1)

time.sleep(10)
													
												
C/C++
GO
Node.js
PHP
Java
Python

Unlock Web data Worldwide

PYPROXY provides high-quality proxies in most regions all around the world. Target the country or city you need to unlock sites and data there.
Canada
Canada
231,080 IPs
USA
USA
1,293,640 IPs
Mexico
Mexico
2,138,920 IPs
Brazil
Brazil
4,726,806 IPs
Argentina
Argentina
1,034,820 IPs
France
France
905,340 IPs
Malaysia
Malaysia
1,520,080 IPs
Philippines
Philippines
1,616,220 IPs
Canada
Canada
231,080 IPs
USA
USA
1,293,640 IPs
Mexico
Mexico
2,138,920 IPs
Brazil
Brazil
4,726,806 IPs
Argentina
Argentina
1,034,820 IPs
France
France
905,340 IPs
Malaysia
Malaysia
1,520,080 IPs
Philippines
Philippines
1,616,220 IPs

Product History of PYPROXY

Jun 2014
Team Construction
Team Construction
Feb 2015
Product Release
Product Release
Aug 2022
S5 Proxies
S5 Proxies
Oct 2022
Unlimited Resi Proxies
Unlimited Resi Proxies
Mar 2023
Reseller System
Reseller System
Apr 2023
Datacenter Proxies
Datacenter Proxies
Jul 2023
PY Wallet
PY Wallet

Premium Customer Service

Customers' satisfaction is our top priority. It's your support that makes us one of the most popular proxy providers. We're always here to support you. We believe your success is our success.
Teach to use proxy
Fix proxy problems
Solve basic tech questions
Customize proxy package

Reviews from our customers

Hailey:
Perfect for web scraping. I've used it for over three months and I'm satisfied with it. The most impressive thing is that they will take customers' advice and add the features you asked for. Great proxy provider ever!
Andrea:
If you want to choose a proxy service, pyproxy is a good choice. Nice product, nice service. I like it a lot. Thumb up.
Raj:
We've had excellent cooperation with pyproxy. I'm glad my friend recommended it to me, which proves to be a correct suggestion. It can be integrated with my tool perfectly. We'll work with pyproxy for a long time.
Noa:
PYPROXY has high-quality IP pool. And its price is not high, which benefits us a lot. They keep adding more IPs and more countries. Very good provider.
Joshua:
I had problem configuring proxies at first. The customer service helped me to fix it and teach me how to customize it. I'm so happy I found pyproxy.
Eva:
I use proxy to manage social media accounts. I tried many proxy providers, and it proves pyproxy is my best choice. Their static ISP proxies are terrific. I renew the IPs every month. My accounts perform well with their proxies.
Maria:
PYPROXY's unlimited proxy is a great innovation. I'm very satisfied with it. I even ask for a customized package, with higher bandwidth. It'll definitely cost more to customize a plan, but it's totally worth it.
James:
It's very easy to learn how to use pyproxy. And I like the city selection feature, which many providers don't have.
Eddie:
Cool product, pyproxy! More and more types of proxies, more and more useful features. How lucky I am that I choose you. Promise me you'll be better!
Tatum:
I've known pyproxy for a long time. I've been with it when it was a new product. It's like watching a baby growing. And it's so grateful that it's becoming better and better. Good luck, my child. We all have bright future.

A trusted partner for 2,000+ companies globally

close
Don't Ghost on These Deals!
Surprise Coupon for Proxies (Resi and S5)
Trick or treat yourself to great offers to enjoy big discount on high-quality residential proxies.
Coupon:
HALLOWEEN2024 copy
UP TO
26%
OFF
Please check the verification result on your Dashboard.