Email
Enterprise Service
Telegram
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 Rotating Proxies
Unlimited Rotating 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.
API
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
United States
United States
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
United States
United States
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 Proxies
Unlimited 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