const rp = require( 'request-promise');
    
    const username = ;
    const password = ;
    const proxyServer = ;
    
    rp({
        url:'http://myip.lunaproxy.io'
        proxy:`http://${username}:${password}@${proxyServer}`,
    })
    .then(function(data){
        console.log(data);
    })
    .catch(function(data){
        console.log(data);
    })

    <?php
    $url = 'http://myip.lunaproxy.io';
    $proxy = ;
    $port = ;
    $user = ;
    $psw = ;
    
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);
    
    curl_setopt($ch, CURLOPT_PROXY, "$proxy:$port");
    curl_setopt($ch, CURLOPT_PROXYUSERPWD, "$user:$psw");
    $result = curl_exec($ch);
    curl_close($ch);
    
    if ($result)
    {
        echo $result . PHP_EOL;
    }
    ?>
    

    package main
    
    import (
        "fmt"
        "io/ioutil"
        "log"
        "net/http"
        "net/url"
    )
    
    const (
        resourceUrl = "http://myip.lunaproxy.io"
        proxyHost   = 
        username    = 
        password    = 
    )
    
    func main() {
        proxyUrl := &url.URL{
            Scheme: "http",
            User:   url.UserPassword(username, password),
            Host:   proxyHost,
        }
    
        client := http.Client{
            Transport: &http.Transport{
                Proxy: http.ProxyURL(proxyUrl),
            },
        }
    
        resp, err := client.Get(resourceUrl)
        if err != nil {
            log.Fatal(err)
        }
        defer resp.Body.Close()
    
        body, err := ioutil.ReadAll(resp.Body)
        if err != nil {
            log.Fatal(err)
        }
    
        bodyString := string(body)
        fmt.Println(bodyString)
    }

    import java.io.*;
    import org.apache.http.HttpHost;
    import org.apache.http.auth.*;
    import org.apache.http.client.CredentialsProvider;
    import org.apache.http.client.methods.*;
    import org.apache.http.impl.client.*;
    import org.apache.http.impl.conn.BasicHttpClientConnectionManager;
    import org.apache.http.util.EntityUtils;
    
    public class JavaHttp {
        public static final String username = ;
        public static final String password = ;
        public static final int port = ;
        public static final String proxyHost = ;
        public CloseableHttpClient client;
    
        public JavaHttp() {
            HttpHost proxy = new HttpHost(proxyHost, port);
            CredentialsProvider cred_provider = new BasicCredentialsProvider();
            cred_provider.setCredentials(new AuthScope(proxy),
                    new UsernamePasswordCredentials(username, password));
            client = HttpClients.custom()
                    .setConnectionManager(new BasicHttpClientConnectionManager())
                    .setProxy(proxy)
                    .setDefaultCredentialsProvider(cred_provider)
                    .build();
        }
    
        public String request(String url) throws IOException {
            HttpGet request = new HttpGet(url);
            CloseableHttpResponse response = client.execute(request);
            try {
                return EntityUtils.toString(response.getEntity());
            } finally { response.close(); }
        }
    
        public void close() throws IOException { client.close(); }
    
        public static void main(String[] args) throws IOException {
            JavaHttp client = new JavaHttp();
            try {
                System.out.println(client.request("http://myip.lunaproxy.io"));
            } finally { client.close(); }
        }
    }

    using System;
    using System.Collections.Generic;
    using System.Linq;
    using System.Net;
    using System.Net.Http;
    using System.Text;
    using System.Threading.Tasks;
    
    class csharp_http
    {
        static void Main(string[] args)
        {
            Task t = new Task(DownloadPageAsync);
            t.Start();
            Console.ReadLine();
        }
    
        static async void DownloadPageAsync()
        {
            string page = "http://myip.lunaproxy.io";
    
            var proxy = new WebProxy()
            {
                UseDefaultCredentials = false,
    
                Credentials = new NetworkCredential(
                    userName: ,
                    password: )
            };
    
            var httpClientHandler = new HttpClientHandler()
            {
                Proxy = proxy,
            };
    
            var client = new HttpClient(handler: httpClientHandler, disposeHandler: true);
            var response = await client.GetAsync(page);
            using (HttpContent content = response.Content)
            {
                string result = await content.ReadAsStringAsync();
                Console.WriteLine(result);
                Console.WriteLine("Press any key to exit.");
                Console.ReadKey();
    
            }
        }
    }

    import requests
    
    username = 
    password = "PJKDKi8vyd"
    proxy_server = "rieg48au.pr.thordata.net:9999"
    
    
    proxies = {"http": f"http://{username}:{password}@{proxy_server}"}
    response = requests.get("http://myip.lunaproxy.io", proxies=proxies)
    print(response.text)
    
                        
    

    require "uri"
    require 'net/http'
    
    proxy_host = 
    proxy_port = 
    proxy_user = 
    proxy_pass = 
    
    uri = URI.parse('http://myip.lunaproxy.io')
    proxy = Net::HTTP::Proxy(proxy_host, proxy_port, proxy_user, proxy_pass)
    
    req = Net::HTTP::Get.new(uri)
    
    result = proxy.start(uri.host, uri.port, use_ssl: true) do |http|
        http.request(req)
    end
    
    puts result.body