Roxlabs全球HTTP代理ip_企业高质量代理服务商-Roxlabs

55Proxy

尊敬的用户：

为保障您的账号安全及享受全面服务，请尽快完成实名认证

个人认证认证成功联系客服免费申请500M测试流量

企业认证待人工审核成功即可到账1G免费流量

实名认证步骤：

点击 “立即实名” 进入认证页面

准确填写个人/企业信息

提交认证审核，静待通过

立即实名

温馨提示

立即认证

管理

退出

代理生成

教程DEMO

min

HTTP 代理主机：

代理端口：

代理用户名：

代理密码：

实例：

复制链接

*本产品需在境外网络环境下使用

代理列表

生成数量：

10 50 100 200 300 400 500 5000 10000

一键复制

参数注释

参数描述必选

zone 代理池标识是

region/st/c 地区标识：region-国家/st-州/c-城市获取全部代码否

sessid 需要固定一个ip时配置，用户自定义否

sessiontime 搭配sessid使用，用于配置ip时效时间，最长不超过30分钟否

keep-true 时效内IP不可用不自动更换IP 否

选择城市/州

要缩小到城市/州级别的定位范围，城市/州需要添加参数。
例如，城市：c-losangeles 意味着来自美国洛杉矶的代理；
州： st-california意味着来自美国加利福尼亚的代理；
Roxlabs支持很多城市/州，但无法保证100%覆盖您需要的城市。大多数受欢迎的城市都有很好的覆盖范围，并且有许多代理可供选择。
在此示例中，从美国洛杉矶的随机 IP 地址执行对 ipinfo.io 的查询：

城市：curl -x pr.roxlabs.cn:4600 -U "user-Uername-c-losangeles-sessid-us1-sesstime-1:password"ipinfo.io

州： curl -x pr.roxlabs.cn:4600 -U "user-Uername-st-california-sessid-us1-sesstime-1:password"ipinfo.io

编程访问

自动化示例

Golang 示例

                                
package main

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

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

// 账密设置
var account = "认证帐户名"
var password = "认证账户密码"

// 代理服务器
var proxyServer = "代理地址"  //示例：xxx.pr.roxlabs.cn:4600;

// 测试地址
var testApi = "https://ipinfo.io"

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

    time.Sleep(time.Minute)
}

// http代理
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代理
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))
    }
}

Node.Js 示例

                                
#!/usr/bin/env node
require('request-promise')({
    url: 'https://ipinfo.io',//请求url
    proxy: 'http://???:????@pr.roxlabs.cn:4600',//认证账户名:认证账户密码@代理地址
    })
.then(function(data){ console.log(data); },
    function(err){ console.error(err); });

Python 示例

                                
'''
导入thread，time，request包,
实现多线程控制，等待，http请求
'''
import _thread
import time
import requests

# 设置请求头
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",
}

# 测试地址
mainUrl = 'https://ipinfo.io'

def testUrl():
    # 设置帐密代理
    proxy = {
        'http': 'http://认证账户名:认证账户密码@代理服务器地址:代理服务器端口',
        'https': 'http://认证账户名:认证账户密码@代理服务器地址:代理服务器端口',
    }
    try:
        res = requests.get(mainUrl, headers=headers, proxies=proxy, timeout=10)
        print(res.status_code, res.text)
    except Exception as e:
        print("访问失败", e)
        pass

# 开启10个线程进行测试
for i in range(0, 10):
    _thread.start_new_thread(testUrl, ())
    time.sleep(0.1)

time.sleep(10)

PHP 示例

                                
<?php
//账密设置
$user = "认证帐户名";
$password = "认证账户密码";
// 要访问的目标页面
$targetUrl = "http://baidu.com";
// 代理服务器
$proxyServer = "代理地址";  //示例：xxx.pr.roxlabs.cn:4600;
$proxyUserPwd = "$user:$password";

// 隧道身份信息
$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);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyUserPwd);
$result = curl_exec($ch);
$err = curl_error($ch);

curl_close($ch);

var_dump($err);
var_dump($result);

C# 示例

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

/*
使用http代理
*/
int GetUrlHTTP(char *url, char *buff)
{
    CURL *curl;
    CURLcode res;
    curl = curl_easy_init();
    if (curl)
    {
        curl_easy_setopt(curl, CURLOPT_PROXY,"http://代理服务器地址:端口");//设置http代理地址
        curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "认证账户名:认证账户密码");//认证账户名及密码，以":"分隔
        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://代理服务器地址:端口");//设置socks5代理地址
        curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, "认证账户名:认证账户密码");//认证账户名及密码，以":"分隔
        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://myip.top", buff);
    printf("不使用代理：%s\n", buff);
    //使用http代理
    memset(buff, 0, 1024 * 1024);
    GetUrlHTTP("http://ipinfo.io", buff);
    printf("http结果：%s\n", buff);
    //使用socks5代理
    memset(buff, 0,1024 * 1024);
    GetUrlSocks5("http://ipinfo.io", buff);
    printf("socks5结果：%s\n", buff);

    free(buff);
    Sleep(10 * 1000);//等待10秒退出
    
    return 0;
}

Java 示例

                                
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代理
        */
    public static void testWithOkHttp() throws IOException {
        String url = "https://ipinfo.io";//请求地址
        //创建一个HTTP类型的代理对象，指定代理服务器的主机名和端口号
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress("host", "port"));//这里用到的"host"和"port"应替换为代理服务器地址和端口。
        // 构建一个自定义的OkHttpClient实例，设置代理服务器并添加一个代理认证器（proxyAuthenticator）：
        OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).proxyAuthenticator((route, response) -> {
            // 在这里生成Basic认证的凭证字符串
            String credential = Credentials.basic("account", "password");//此处的账号密码 "account" 和 "password" 应替换为认证账户名和认证账户密码。
            // 如果代理服务器需要身份验证，则在请求头中添加认证信息
            return response.request().newBuilder()
                    .header("Proxy-Authorization", credential)
                    .build();
        }).build();

        //发送GET请求并获取响应：
        Request request = new Request.Builder().url(url).build();
        okhttp3.Response response = client.newCall(request).execute();
        //获取并打印响应内容：
        String responseString = response.body().string();
        System.out.println(responseString);
    }

    /**
        * Socks5代理
        */
    public static void testSocks5WithOkHttp() throws IOException {
        //请求地址
        String url = "https://ipinfo.io";
        //创建一个SOCKS类型的代理对象，设置实际的代理服务器主机名和端口号：
        Proxy proxy = new Proxy(Proxy.Type.SOCKS, new InetSocketAddress("host", "port"));//这里用到的"host"和"port"应替换为代理服务器地址和端口。
        //设置全局默认的认证器（Authenticator），用于处理所有网络连接需要的基本身份验证。这里预设了一个用户名和密码：
        java.net.Authenticator.setDefault(new java.net.Authenticator() {
            private PasswordAuthentication authentication =
                    new PasswordAuthentication("account", "password".toCharArray());//此处的账号密码 "account" 和 "password" 应替换为认证账户名和认证账户密码。

            @Override
            protected PasswordAuthentication getPasswordAuthentication() 
        });
        //构建OkHttpClient实例，配置好SOCKS代理：
        OkHttpClient client = new OkHttpClient().newBuilder().proxy(proxy).build();
        //发送GET请求并获取响应：
        Request request = new Request.Builder().url(url).build();
        okhttp3.Response response = client.newCall(request).execute();
        //获取并打印响应内容：
        String responseString = response.body().string();
        System.out.println(responseString);
    }
}

Python-Selenium 示例

                                
# -*- coding: utf-8 -*-
import string
import zipfile
from selenium.webdriver import ChromeOptions
from selenium.webdriver import Chrome
import time

# 代理隧道验证信息（账号+密码）
proxyUser = "" #认证帐户名
proxyPass = "" #认证账户密码
proxyHost = "" #代理服务器地址，示例:192.168.0.1
proxyPort = 4600 #端口

'''
此方法为谷歌帐密认证插件的固定方法
只需要将对应的参数传入即可
'''
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
# 实例化chromedriver设置
chrome_options = ChromeOptions()
# 调用创建帐密认证的方法，传对应的参数，添加到chromedriver设置中
chrome_options.add_extension(create_proxy_auth_extension(proxyHost,proxyPort,proxyUser,proxyPass))
# 配置已设置的chromedriver参数
driver = Chrome(options=chrome_options)
# 要访问的目标页面
driver.get('url')
# 获取访问页面的页面信息并打印
text = driver.page_source
print(text)
time.sleep(10)
# 访问完退出
driver.quit()