<?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;
}
?>

Unlimited traffic proxy to collect LLM training data

Overcoming LLM training data collection challenges

Massive data demand
Bypass IP blocks and CAPTCHAs


Dedicated unlimited traffic proxy
Unlimited scalability


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
Unlock the advantages of unlimited traffic proxy

Top IP quality
Ethically sourced infrastructure with top IPs to effortlessly overcome IP bans and complex CAPTCHA challenges to ensure uninterrupted access to any website.

Enhanced data collection and LLM training
Collect a large amount of public data with unlimited traffic for LLM model training and analysis, and obtain comprehensive and accurate data sets at a lower cost.

Any custom solution
LunaProxy's unlimited traffic proxy is designed for multi-modal training data collection such as YouTube/Github/audio, etc., and will not cause IP timeout. You can customize any of our solutions to meet specific requirements.
Meet the full-modal LLM training data collection

YouTube proxy IP
Customized exclusive proxy pool, supports 100Gbps+ bandwidth, unlimited traffic proxy to unlock YT restrictions.

Unlimited text data download
Fixed billing only by time, unlimited traffic usage, unlimited crawling of website data.

Image and audio proxy IP
Simulate real user actions to evade anti-crawling limits and quickly download multimodal data for LLM training.
Explore our compatibility with all LLM workflows


Seamless integration of unlimited traffic proxy

Explore Unlimited Proxy Pricing
Residential Proxies Plan
200M+ residential IPs in 195 Country, state, city and zip code geo-targeting free!
Unlimited Proxies Plan
Take advantage of unlimited data for seamless browsing and crawling
Rotating ISP Proxies Plan
Pick a plan that suits you. Get ahead with unlockable and stable proxies
ISP Proxies Plan
Improve your online security with cost-effective ISP Proxies
Datacenter Proxies Plan
Fastest IPv4 datacenter proxy servers with zero blocks and downtime for all your needs
Residential Proxies
(Added 220,000 US IP)
Get $5 off
Unlimited Proxies
(Unlimited traffic)
ISP
($0.17/IP/Day)
Datacenter
Rotating ISP

















This information is used for verification purposes and is not visible to the public. Inconsistencies with company documents will result in verification failure
Frequently asked questions
Yes. Our unlimited traffic proxies have unlimited traffic usage, unlimited IP usage, unlimited concurrency, and are an unlimited traffic proxy IP solution specifically for LLM training data collection.
Through our global dynamic IP pool rotation, we support targeted collection in different countries and regions, and automatically capture multi-language and multi-modal data. At the same time, we support mixed crawling of text, images, videos, and audio.
Data crawling (also known as web crawling) is the process of extracting data from a website. The collected data is cleaned and formatted and can be used for a variety of purposes. The most popular use cases include LLM model training, market research, content aggregation, sentiment analysis, and data mining.