18505165572
13063531397
1000万+IP
纯净住宅代理
200+地区
全球覆盖
99.2%
高可用率
24/7
实时技术支持
Roxlabs代理不限带宽，IP资源池24小时去重，保障动态住宅代理快速运行，平均响应时间为0.6秒。技术团队全程监测系统，客服团队随时解答用户问题。
Roxlabs动态住宅支持1-1440分钟自定义IP时效，可以根据业务需求自主设定会话时长。支持HTTP/HTTPS/SOCKS5代理协议，自由设置API提取导出格式。
Roxlabs个人中心实时统计代理使用数据，您可以随时查看账户余额信息和流量使用情况，支持添加多个IP白名单和认证账户，更有IP管理、认证账户管理等功能。
1000万+纯净住宅IP
覆盖200+地区
HTTP/HTTPS/SOCKS5
专享代理资源池
高性价比价格，节约企业成本
自定义IP时效，满足多种业务需求
一对一客户服务，随时解决问题
技术团队全程监测，保障系统稳定运行
from selenium import webdriver
import requests
def seleniumSetUP(ip,port):
# 设置Chrome驱动程序的路径
chromedriver_path = './chromedriver.exe'
# 创建Chrome浏览器实例
chrome_options = webdriver.ChromeOptions()
browser = webdriver.Chrome(chromedriver_path, chrome_options=chrome_options)
chrome_options.add_argument(f'--proxy-server=http://{ip}:{port}')
browser.get('http://ipinfo.io')
print(browser.page_source)
if __name__ == '__main__':
porxyUrl = "http://api.proxy.ipidea.io/getProxyIp?num=1&return_type=json&lb=1&sb=0&flow=1®ions=&protocol=http"
ipInfo = requests.get(porxyUrl)
info = ipInfo.json()["data"]
ip = info[0]["ip"]
port = info[0]["port"]
seleniumSetUP(ip,port)
Php http/sock5:#coding=utf-8
import requests
#请求地址
targetUrl = "https://www.baidu.com"
#代理服务器
proxyHost = "ip"
proxyPort = "port"
proxyMeta = "http://%(host)s:%(port)s" % {
"host" : proxyHost,
"port" : proxyPort,
}
#pip install -U requests[socks] socks5
# proxyMeta = "socks5://%(host)s:%(port)s" % {
# "host" : proxyHost,
# "port" : proxyPort,
# }
proxies = {
"http" : proxyMeta,
"https" : proxyMeta
}
resp = requests.get(targetUrl, proxies=proxies)
print resp.status_code
print resp.text
Phantomjs http/socks5:
phantomjs --proxy=ip:port --proxy-type=[http|socks5|none] demo.js
//node代理请求http
var http = require('http')
var opt = {
host: 'tunnel.alicloudecs.com',//这里放代理服务器的ip或者域名
port: '500',//这里放代理服务器的端口号
method: 'GET',//这里是发送的方法
path: 'http://myip.top/', //这里是访问的路径
}
//以下是接收数据的代码
var body = '';
var req = http.request(opt, function (res) {
console.log("Got response: " + res.statusCode);
res.on('data', function (d) {
body += d;
}).on('end', function () {
console.log(res.headers)
console.log(body)
});
}).on('error', function (e) {
console.log("Got error: " + e.message);
})
req.end();
//node代理请求http/https
const fetch = require("node-fetch");
const HttpsProxyAgent = require('https-proxy-agent');
//这里是访问的路径
let url="https://www.baidu.com/s?cl=3&tn=baidutop10&fr=top1000&wd=%E9%AB%98%E8%80%83&rsv_idx=2&rsv_dl=fyb_n_homepage&hisfilter=1";
//这是代理服务器地址
let ip='58.218.205.48';
//这是端口号
let port='500';
fetch(url, {
method: 'GET',
// body: null,
agent: new HttpsProxyAgent("http://" + ip + ":" + port) //<==注意是 `http://`
}).then(function (res) {
console.log("Response Headers ============ ");
res.headers.forEach(function(v,i,a) {
console.log(i+" : "+v);
});
return res.text();
}).then(function (res) {
console.log("Response Body ============ ");
console.log(res);
});
#coding=utf-8
Php http/sock5:
// 要访问的目标页面
$targetUrl = "http://baidu.com";
// 代理服务器
$proxyServer = "http":"http://ip:port";
// 隧道身份信息
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $targetUrl);
curl_setopt($ch, CURLOPT_HTTPPROXYTUNNEL, false);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
// 设置代理服务器
//curl_setopt($ch, CURLOPT_PROXYTYPE, 0); //http
curl_setopt($ch, CURLOPT_PROXYTYPE, 5); //sock5
curl_setopt($ch, CURLOPT_PROXY, $proxyServer);
// 设置隧道验证信息
curl_setopt($ch, CURLOPT_PROXYAUTH, CURLAUTH_BASIC);
curl_setopt($ch, CURLOPT_USERAGENT, "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; SV1; .NET CLR 2.0.50727;)");
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT, 3);
curl_setopt($ch, CURLOPT_TIMEOUT, 5);
curl_setopt($ch, CURLOPT_HEADER, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$result = curl_exec($ch);
curl_close($ch);
var_dump($result);
package main
import (
"fmt"
"golang.org/x/net/proxy"
"io/ioutil"
"net"
"net/http"
"net/url"
"os"
"time"
)
var testApi = "http://myip.top/"
func main() {
fmt.Println("代理测试")
go httpProxy("124.156.245.161", 10021)
go socks5Proxy("150.109.186.75", 6211)
time.Sleep(time.Hour)
}
func httpProxy(ip string, port int) {
defer func() {
if err := recover(); err != nil {
fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "http", "返回信息:", err)
}
}()
urli := url.URL{}
urlproxy, _ := urli.Parse(fmt.Sprintf("http://%s:%d", ip, port))
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, err := ioutil.ReadAll(response.Body)
if err != nil {
panic(err)
return
}
fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "http", "返回信息:", string(body))
return
}
func socks5Proxy(ip string, port int) {
dialer, err := proxy.SOCKS5("tcp", fmt.Sprintf("%s:%d", ip, port), nil, proxy.Direct)
if err != nil {
_, _ = fmt.Println("can't connect to the proxy:", err.Error())
os.Exit(1)
}
//setup a http client
httpClient := &http.Client{
Transport: &http.Transport{
Dial: func(network, addr string) (net.Conn, error) {
return dialer.Dial(network, addr)
},
},
}
httpClient.Timeout = time.Second * 10
// set our socks5 as the dialer
if resp, err := httpClient.Get(testApi); err != nil {
fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "socks5", "返回信息:", err.Error())
} else {
defer resp.Body.Close()
body, _ := ioutil.ReadAll(resp.Body)
fmt.Println(time.Now().Format("2006-01-02 15:04:05 07"), "socks5", "返回信息:", string(body))
}
}
//http：
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.config.RequestConfig;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClientBuilder;
import org.apache.hc.core5.http.HttpEntity;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.ParseException;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import java.io.IOException;
import java.nio.charset.StandardCharsets;
/**
* Create by ipidea on 2021/2/6
*
* 依赖 compile 'org.apache.httpcomponents.client5:httpclient5:5.0.3'
*
* @see httpcomponents
*/
class HttpProxy {
public static void httpProxy() {
HttpGet request = new HttpGet("http://ky.myip.top/");
RequestConfig requestConfig = RequestConfig.custom()
.setProxy(new HttpHost("221.229.173.99", 13001))
.build();
request.setConfig(requestConfig);
try {
CloseableHttpClient httpClient = HttpClientBuilder.create()
.disableRedirectHandling()
.build();
CloseableHttpResponse response = httpClient.execute(request);
// Get HttpResponse Status
System.out.println(response.getVersion());
System.out.println(response.getCode());
System.out.println(response.getReasonPhrase());
HttpEntity entity = response.getEntity();
if (entity != null) {
// return it as a String
String result = EntityUtils.toString(entity, StandardCharsets.UTF_8);
System.out.println(result);
}
} catch (ParseException | IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
httpProxy();
}
}
//socks5
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.classic.CloseableHttpClient;
import org.apache.hc.client5.http.impl.classic.CloseableHttpResponse;
import org.apache.hc.client5.http.impl.classic.HttpClients;
import org.apache.hc.client5.http.impl.io.PoolingHttpClientConnectionManager;
import org.apache.hc.client5.http.protocol.HttpClientContext;
import org.apache.hc.client5.http.socket.ConnectionSocketFactory;
import org.apache.hc.client5.http.socket.PlainConnectionSocketFactory;
import org.apache.hc.client5.http.ssl.SSLConnectionSocketFactory;
import org.apache.hc.core5.http.HttpHost;
import org.apache.hc.core5.http.config.Registry;
import org.apache.hc.core5.http.config.RegistryBuilder;
import org.apache.hc.core5.http.io.entity.EntityUtils;
import org.apache.hc.core5.http.protocol.HttpContext;
import org.apache.hc.core5.ssl.SSLContexts;
import org.apache.hc.core5.util.TimeValue;
import javax.net.ssl.SSLContext;
import java.io.IOException;
import java.net.InetSocketAddress;
import java.net.Proxy;
import java.net.Socket;
import java.util.Map;
/**
* Create by ipidea on 2021/2/6
*
* 依赖 compile 'org.apache.httpcomponents.client5:httpclient5:5.0.3'
*
* @see httpcomponents
*/
class Socks5Proxy {
public static String socks5Proxy(String url, Map headers, String charset) {
Registry reg = RegistryBuilder.create()
.register("http", new MyConnectionSocketFactory())
.register("https", new MySSLConnectionSocketFactory(SSLContexts.createSystemDefault()))
.build();
PoolingHttpClientConnectionManager cm = new PoolingHttpClientConnectionManager(reg);
CloseableHttpClient httpclient = HttpClients.custom().setConnectionManager(cm).build();
try {
String proxyHost = "221.229.173.99";
int proxyPort = 13001;
InetSocketAddress socksAddr = new InetSocketAddress(proxyHost, proxyPort);
HttpClientContext context = HttpClientContext.create();
context.setAttribute("socks.address", socksAddr);
HttpGet httpget = new HttpGet(url);
if (headers != null) {
for (String key : headers.keySet()) {
httpget.setHeader(key, headers.get(key));
}
}
try (CloseableHttpResponse response = httpclient.execute(httpget, context)) {
return new String(EntityUtils.toByteArray(response.getEntity()), charset);
}
} catch (Exception e) {
e.printStackTrace();
} finally {
try {
httpclient.close();
} catch (Exception e2) {
e2.printStackTrace();
}
}
return null;
}
static class MyConnectionSocketFactory extends PlainConnectionSocketFactory {
@Override
public Socket createSocket(final HttpContext context) {
InetSocketAddress socksAddr = (InetSocketAddress) context.getAttribute("socks.address");
Proxy proxy = new Proxy(Proxy.Type.SOCKS, socksAddr);
return new Socket(proxy);
}
@Override
public Socket connectSocket(TimeValue connectTimeout, Socket socket, HttpHost host, InetSocketAddress remoteAddress,
InetSocketAddress localAddress, HttpContext context) throws IOException {
InetSocketAddress unresolvedRemote = InetSocketAddress
.createUnresolved(host.getHostName(), remoteAddress.getPort());
return super.connectSocket(connectTimeout, socket, host, unresolvedRemote, localAddress, context);
}
}
static class MySSLConnectionSocketFactory extends SSLConnectionSocketFactory {
public MySSLConnectionSocketFactory(final SSLContext sslContext) {
super(sslContext);
}
@Override
public Socket createSocket(final HttpContext context) throws IOException {
InetSocketAddress socksAddr = (InetSocketAddress) context.getAttribute("socks.address");
Proxy proxy = new Proxy(Proxy.Type.SOCKS, socksAddr);
return new Socket(proxy);
}
@Override
public Socket connectSocket(TimeValue connectTimeout, Socket socket, HttpHost host,
InetSocketAddress remoteAddress, InetSocketAddress localAddress,
HttpContext context) throws IOException {
InetSocketAddress unresolvedRemote = InetSocketAddress
.createUnresolved(host.getHostName(), remoteAddress.getPort());
return super.connectSocket(connectTimeout, socket, host, unresolvedRemote, localAddress, context);
}
}
public static void main(String[] args) {
String msg = socks5Proxy("http://ky.myip.top/", null, "UTF-8");
System.out.println(msg);
}
}
// demo.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include "curl/curl.h"
#pragma comment(lib, "libcurl.lib")
//curl 回调函数
static size_t write_buff_data(char *buffer, size_t size, size_t nitems, void *outstream)
{ //把接收的数据拷贝到缓存中
memcpy(outstream, buffer, nitems*size);
return nitems*size;
}
/*
使用http代理
*/
int GetUrlHTTP(char *url, char *buff)
{
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if (curl)
{
curl_easy_setopt(curl, CURLOPT_PROXY,"http://测试ip:端口");//设置http代理地址
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//设置读写缓存
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//设置回调函数
curl_easy_setopt(curl, CURLOPT_URL, url);//设置url地址
curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//设置一个长整形数，控制多少秒传送CURLOPT_LOW_SPEED_LIMIT规定的字节数
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\n", res);
MessageBox(NULL, TEXT("获取IP错误"), TEXT("助手"), MB_ICONINFORMATION | MB_YESNO);
}
}
return res;
}
/*
使用socks5代理
*/
int GetUrlSocks5(char *url, char *buff)
{
CURL *curl;
CURLcode res;
curl = curl_easy_init();
if (curl)
{
curl_easy_setopt(curl, CURLOPT_PROXY, "socks5://测试ip:端口");//设置socks5代理地址
curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void*)buff);//设置读写缓存
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_buff_data);//设置回调函数
curl_easy_setopt(curl, CURLOPT_URL, url);//设置url地址
curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//设置一个长整形数，控制多少秒传送CURLOPT_LOW_SPEED_LIMIT规定的字节数
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\n", res);
MessageBox(NULL, TEXT("获取IP错误"), TEXT("助手"), MB_ICONINFORMATION | MB_YESNO);
}
}
return res;
}
int GetUrl(char *url, char *buff)
{
CURL *curl;
CURLcode res;
//使用的curl库 初始化curl库
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);//设置url地址
curl_easy_setopt(curl, CURLOPT_LOW_SPEED_TIME, 10L);//设置一个长整形数，控制多少秒传送CURLOPT_LOW_SPEED_LIMIT规定的字节数
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\n", res);
MessageBox(NULL, TEXT("获取IP错误"), TEXT("助手"), MB_ICONINFORMATION | MB_YESNO);
}
}
return res;
}
int main()
{
char *buff=(char*)malloc(1024*1024);
memset(buff, 0, 1024 * 1024);
//不使用http代理
GetUrl("http://baidu.com", buff);
printf("不使用代理：%s\n", buff);
//使用http代理
memset(buff, 0, 1024 * 1024);
GetUrlHTTP("http://baidu.com", buff);
printf("http结果：%s\n", buff);
//使用socks5代理
memset(buff, 0,1024 * 1024);
GetUrlSocks5("http://baidu.com", buff);
printf("socks5结果：%s\n", buff);
Sleep(1000 * 1000);
free(buff);
return 0;
}
# -*- coding: utf-8 -*-
import string
import zipfile
from selenium.webdriver import ChromeOptions
from selenium.webdriver import Chrome
import time
# 代理隧道验证信息（账号+密码）
proxyUser = ""
proxyPass = ""
proxyHost = ""
proxyPort = 2334
def create_proxy_auth_extension(proxy_host, proxy_port, proxy_username, proxy_password, scheme='http', plugin_path=None):
if plugin_path is None:
plugin_path = r'{}_{}@verification.zip'.format(proxy_username, proxy_password)
manifest_json = """
{
"version": "1.0.0",
"manifest_version": 2,
"name": "Dobel Proxy",
"permissions": [
"proxy",
"tabs",
"unlimitedStorage",
"storage",
"< all_urls >",
"webRequest",
"webRequestBlocking"
],
"background": {
"scripts": ["background.js"]
},
"minimum_chrome_version":"22.0.0"
}
"""
background_js = string.Template(
"""
var config = {
mode: "fixed_servers",
rules: {
singleProxy: {
scheme: "${scheme}",
host: "${host}",
port: parseInt(${port})
},
bypassList: ["foobar.com"]
}
};
chrome.proxy.settings.set({value: config, scope: "regular"}, function() {});
function callbackFn(details) {
return {
authCredentials: {
username: "${username}",
password: "${password}"
}
};
}
chrome.webRequest.onAuthRequired.addListener(
callbackFn,
{urls: ["< all_urls >"]},
['blocking']
);
"""
).substitute(
host=proxy_host,
port=proxy_port,
username=proxy_username,
password=proxy_password,
scheme=scheme,
)
with zipfile.ZipFile(plugin_path, 'w') as zp:
zp.writestr("manifest.json", manifest_json)
zp.writestr("background.js", background_js)
return plugin_path
chrome_options = ChromeOptions()
chrome_options.add_extension(create_proxy_auth_extension(proxyHost, proxyPort, proxyUser, proxyPass))
driver = Chrome(options=chrome_options)
# 要访问的目标页面
driver.get('url')
text = driver.page_source
print(text)
time.sleep(10)
driver.quit()
import requests
http_proxy = ":@:4600"
https_proxy = ":@:4600"
url = "myip.roxlabs.io"
proxyDict = {
"http": http_proxy,
"https": https_proxy,
}
r = requests.get(url, proxies=proxyDict)
...
const got = require('got');
const {
HttpsProxyAgent
} = require('hpagent');
got('myip.roxlabs.io', {
agent: {
https: new HttpsProxyAgent({
proxy: 'https://:@:4600'
})
}
}).then(respone => {
console.log(respone.body);
}).catch(err => {
console.log(err.response.body);
});
const request = require('request');
const proxy = "https://:@:4600"
const url = "myip.roxlabs.io";
const proxiedRequest = request.defaults({
'proxy': proxy
});
proxiedRequest.get(url, function(err, resp, body) {
...
});
$curl = curl_init();
curl_setopt_array($curl, array(
CURLOPT_URL => "myip.roxlabs.io",
CURLOPT_PROXY => "https://:@:4600"
CURLOPT_FOLLOWLOCATION => 1,
CURLOPT_RETURNTRANSFER => 1,
));
$response = curl_exec($curl);
...
proxy := "https://:@:4600"
url := "myip.roxlabs.io"
os.Setenv("HTTP_PROXY", proxy)
resp, err := http.Get(url)
...
import java.net. * ;
import java.io. * ;
public class ProxyConnect {
public static void main(String[] args) throws MalformedURLException,
ProtocolException,
IOException {
final String authUser = "";
final String authPassword = "";
final String proxyHost = "";
final int proxyPort = 4600;
final String destURL = "myip.roxlabs.io";
System.setProperty("jdk.http.auth.tunneling.disabledSchemes", "");
System.setProperty("jdk.http.auth.proxying.disabledSchemes", "");
Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));
URL url = new URL(destURL);
HttpURLConnection connection = (HttpURLConnection) url.openConnection(proxy);
Authenticator.setDefault(new Authenticator() {@Override
protected PasswordAuthentication getPasswordAuthentication() {
if (getRequestorType().equals(RequestorType.PROXY)) {
return new PasswordAuthentication(authUser, authPassword.toCharArray());
}
return super.getPasswordAuthentication();
}
});
StringBuilder content;
try (BufferedReader in =new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
String line;
content = new StringBuilder();
while ((line = in.readLine()) != null) {
content.append(line);
content.append(System.lineSeparator());
}
System.out.println(content.toString());
} catch(Throwable e) {
System.err.println(e);
} finally {
connection.disconnect();
}
}
}
using System;
using System.IO;
using System.Net;
namespace packetstreamExample {
class ProxyConnect {
static void Main(string[] args) {
string proxyUser = "";
string proxyPass = "";
WebProxy proxyObject = new WebProxy(":4600", true);
proxyObject.Credentials = new NetworkCredential(proxyUser, proxyPass);
WebRequest request = WebRequest.Create("myip.roxlabs.io");
request.Proxy = proxyObject;
HttpWebResponse response = (HttpWebResponse) request.GetResponse();
Console.WriteLine(response.StatusDescription);
Stream dataStream = response.GetResponseStream();
StreamReader reader = new StreamReader(dataStream);
string responseFromServer = reader.ReadToEnd();
Console.WriteLine(responseFromServer);
reader.Close();
dataStream.Close();
response.Close();
...
}
}
}
