curl -x pr.lunaproxy.com:12233 -U "USER:PASS" myip.lunaproxy.io

import fetch from 'node-fetch';
import createHttpsProxyAgent from 'https-proxy-agent'

const username = 'customer-USER';
const password = 'PASS';
const proxy = 'ip:port'

const agent = createHttpsProxyAgent(
`http://${username}:${password}@${proxy}`
);

const response = await fetch('myip.lunaproxy.io', {
method: 'get',
agent: agent,
});

console.log(await response.text());


                            

<?php
$username = 'customer-USER';
$password = 'PASS';
$proxy = 'ip:port';

$query = curl_init('myip.lunaproxy.io');

curl_setopt($query, CURLOPT_RETURNTRANSFER, 1);
curl_setopt($query, CURLOPT_PROXY, "http://$proxy");
curl_setopt($query, CURLOPT_PROXYUSERPWD, "$username:$password");

$output = curl_exec($query);
curl_close($query);
if ($output)
echo $output;
?>
                            

package main

import (
"fmt"
"io/ioutil"
"net/http"
"net/url"
)

func main() {
const username = "customer-USER"
const password = "PASS"
const proxy = "ip:port"

proxyUrl, _ := url.Parse(
fmt.Sprintf(
"http://%s:%s@%s",
username,
password,
proxy,
),
)

client := &http.Client{Transport: &http.Transport{Proxy: http.ProxyURL(proxyUrl)}}
request, _ := http.NewRequest("GET",
"myip.lunaproxy.io",
nil,
)

request.SetBasicAuth(username, password)
response, err := client.Do(request)
if err != nil {
fmt.Println(err)
return
}

responseText, _ := ioutil.ReadAll(response.Body)
fmt.Println(string(responseText))
}
                                

package example;

import org.apache.http.HttpHost;
import org.apache.http.client.fluent.*;

public class Main {
public static void main(String[] args) throws Exception {

String username = "customer-USER";
String password = "PASS";
String proxyHost = "pr.lunaproxy.com";
int proxyPort = 12233;

HttpHost entry = new HttpHost(proxyHost, proxyPort);
String query = Executor.newInstance()
.auth(entry, username, password)
.execute(
Request.Get("myip.lunaproxy.io")
    .viaProxy(entry)
)
.returnContent()
.asString();
System.out.println(query);
}
}
                            

using System;
using System.Net;

class Example
{
static void Main()
{   
var username = "customer-USER";
var password = "PASS";
var proxy = "ip:port";

var client = new WebClient();
client.Proxy = new WebProxy(proxy);
client.Proxy.Credentials = new NetworkCredential(username, password);
Console.WriteLine(
client.DownloadString("myip.lunaproxy.io")
);
}
}
                        

import base64

class SmartProxyAuthMiddleware(object):

def __init__(self, settings):
self.proxy_url = 'http://%s:%d' % ("http://myip.lunaproxy.io", 1000)
self.proxy_auth = "Basic " + base64.urlsafe_b64encode(bytes(("ada202301:ozGOb1iuY"), "ascii")).decode("utf8")

@classmethod
def from_crawler(cls, crawler):
s = cls(crawler.settings)
return s

def process_request(self, request, spider):
request.meta["proxy"] = self.proxy_url
request.headers["Proxy-Authorization"] = self.proxy_auth

def process_response(self, request, response, spider):
spider.logger.info('%d for url[%s] with smart_proxy' % (response.status, response.url))

if response.status >= 300:
new_req = request.replace(dont_filter=True)
spider.logger.warning('retry url[%s] for status[%d] with smart_proxy' % (response.url, response.status))

return new_req

return response

def process_exception(self, request, exception, spider):
spider.logger.error('url[%s] with error[%s]' % (request.url, exception))