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

import requests
				
mainUrl  = "http://myip.lunaproxy.io/"
				
def testUrl():
				
entry = 'http://{}:{}@ip:port'.format("username", "password")
proxy = {
	  'http': entry,
	  'https': entry,
}
try:
				
res = requests.get(mainUrl, proxies=proxy, timeout=10)
				
print(res.status_code, res.text)
				
except Exception as e:
				
print("error", e)
				
pass
				
testUrl()
				
				
											

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

require 'uri'
require 'net/http'

uri = URI.parse('myip.lunaproxy.io')
proxy = Net::HTTP::Proxy('http://myip.lunaproxy.io', 1000, 'ada202301', 'ozGOb1iuY')

req = Net::HTTP::Get.new(uri.path)

result = proxy.start(uri.host,uri.port) do |http|
	http.request(req)
end

puts result.body

fn main() {
	let proxy = reqwest::Proxy::all("http://myip.lunaproxy.io:12233").
		unwrap().basic_auth("ada202301","ozGOb1iuY");
	let client = reqwest::blocking::Client::builder().proxy(proxy).build().unwrap();
	let resp = client.get("myip.lunaproxy.io").send().unwrap();

	println!("{}",resp.text().unwrap());
}