Unlimited traffic proxy to collect LLM training data

<?php
$url = "http://myip.lunaproxy.io";
$proxy = "pr.lunaproxy.com:12233";
$user = "user-USERNAME";
$psw = "PASS";

$ch = curl_init($url);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, 1);

curl_setopt($ch, CURLOPT_PROXY, "$proxy");
curl_setopt($ch, CURLOPT_PROXYUSERPWD, "$user:$psw");
$result = curl_exec($ch);
curl_close($ch);

if ($result)
{
echo $result . PHP_EOL;
}
?>

const rp = require( 'request-promise');

const username = "user-USERNAME";
const password = "PASS";
const proxyServer = "pr.lunaproxy.com:12233";

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

import requests

username = "user-USERNAME"
password = "PASS"
proxy_server = "pr.lunaproxy.com:12233"


proxies = {"http": f"http://{username}:{password}@{proxy_server}"}
response = requests.get("http://myip.lunaproxy.io", proxies=proxies)
print(response.text)

                

package main

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

const (
resourceUrl = "http://myip.lunaproxy.io"
proxyHost   = "pr.lunaproxy.com:12233"
username    = "user-USERNAME"
password    = "PASS"
)

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 = "user-USERNAME";
public static final String password = "PASS";
public static final int port = 12233;
public static final String proxyHost = "pr.lunaproxy.com";
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: "user-USERNAME",
            password: "PASS")
    };

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

    }
}
}

require "uri"
require 'net/http'

proxy_host = "pr.lunaproxy.com"
proxy_port = 12233

uri = URI.parse('http://myip.lunaproxy.io')
proxy = Net::HTTP::Proxy(proxy_host, proxy_port)  # No longer use username and password

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