点击这里给我发消息
QQ客服
微信客服
   18505165572
   13063531397

全球IP代理服务商
千万优质动态住宅

汇集全球200+国家地区的真实住宅IP,支持HTTP/HTTPS/SOCKS5代理协议,让数据采集更简单。

roxlabs代理http
  • 1000万+IP

    纯净住宅代理

  • 200+地区

    全球覆盖

  • 99.2%

    高可用率

  • 24/7

    实时技术支持

Roxlabs代理的核心优势

roxlabs代理http

不限并发会话

Roxlabs支持无限并发会话,不限带宽,无需额外费用,满足您的业务拓展需求。
roxlabs代理http

城市级定位

Roxlabs提供国家、城市和州级精准定位IP,支持HTTP(S)/Socks5代理协议。
roxlabs代理http

套餐不过期

Roxlabs提供流量套餐和额度套餐,套餐无使用期限,无需担心剩余流量或额度过期。
住宅IP代理

代理快速响应

Roxlabs代理不限带宽,IP资源池24小时去重,保障动态住宅代理快速运行,平均响应时间为0.6秒。技术团队全程监测系统,客服团队随时解答用户问题。

自定义IP时效

Roxlabs动态住宅支持1-1440分钟自定义IP时效,可以根据业务需求自主设定会话时长。支持HTTP/HTTPS/SOCKS5代理协议,自由设置API提取导出格式。

数据中心代理IP
数据采集IP代理

数据统计中心

Roxlabs个人中心实时统计代理使用数据,您可以随时查看账户余额信息和流量使用情况,支持添加多个IP白名单和认证账户,更有IP管理、认证账户管理等功能。

全球热门代理地区

1000万+纯净住宅IP
覆盖200+地区
HTTP/HTTPS/SOCKS5
美国静态代理IP
美国
2,106,985 IPs
印度静态代理IP
印度
1,654,358 IPs
英国静态代理IP
英国
476,412 IPs
土耳其静态代理IP
土耳其
89,398 IPs
加拿大静态代理IP
加拿大
384,218 IPs
巴西静态代理IP
巴西
421,498 IPs
意大利静态代理IP
意大利
921,546 IPs
马来西亚静态代理IP
马来西亚
152,784 IPs
德国静态代理IP
德国
421,362 IPs
印度尼西亚静态代理IP
印度尼西亚
132,158 IPs
越南静态代理IP
越南
148,628 IPs
法国静态代理IP
法国
215,688 IPs
更多地区资源
加拿大
384,218 IPs
美国
2,106,985 IPs
巴西
421,498 IPs
英国
476,412 IPs
法国
215,688 IPs
意大利
921,546 IPs
越南
148,628 IPs
德国
421,362 IPs
土耳其
89,398 IPs
印度
1,654,358 IPs
马来西亚
152,784 IPs
印度尼西亚
132,158 IPs

优质大数据采集解决方案

高性价比的代理资源,为企业提供完善代理服务
平均 99.2% 成功率
24/7 实时支持
城市级定位
  • 动态住宅代理

    便于大数据采集的高匿轮转住宅IP

    1000万+动态住宅IP
    查看价格
    无限并发会话
    城市级精准定位
    流量不过期
  • 静态住宅代理

    99.9%正常稳定运行的长效住宅IP

    50万+静态住宅
    查看价格
    原生独享IP
    不限流量
    支持HTTP(S)/Socks5代理协议
  • 独享数据中心代理

    便于获取的优质高速长效机房IP

    60万+独享数据中心
    查看价格
    个人专享IP
    不限流量
    支持HTTP(S)/Socks5代理协议

免费定制专属解决方案

专享代理资源池
高性价比价格,节约企业成本
自定义IP时效,满足多种业务需求
一对一客户服务,随时解决问题
技术团队全程监测,保障系统稳定运行

Roxlabs常见应用场景

Roxlabs为数据采集、跨境电商、社交媒体、网络安全、市场调研等行业领导者提供专业的大数据采集解决方案

数据采集

轻松实现高效数据采集,提高工作效率和质量

SEO监测

实时掌握有关竞争性SEO实践和策略的数据

竞品追踪

及时获取新的竞品信息及定价数据

广告验证

保障产品在全球范围内的广告投放准确性

品牌保护

防止假冒伪劣品牌损害正品形象和利益

市场调查

收集市场真实有效数据,保持竞争优势

账号管理

创建和管理不同平台的账号,满足多任务需求

网络安全

避免遭受网络恶意攻击,保护隐私安全

网站测试

帮助测试网站参数,保障网站本地化

旅游聚合

获取优惠的机票酒店价格,节约旅游成本

Roxlabs多种代码轻松集成

各种常见的爬虫编程语言代码示例以及API参数注释确保您可以快速开始使用Roxlabs。
C++
Go
PhantomJS
PHP
Java
Python
Python-Selenium
Node.Js
                            
    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;
    
    }
                            
                        
Go
Node.Js(Got)
Node.Js(Request)
Python
PHP
C#
Java
Python-Selenium
                            
    # -*- 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();
    ...
    }
    }
    }