Residential proxies,
without a subscription.

python -m pip install requests

import os
import requests

proxy_url = os.environ["HASDATA_PROXY_URL"]
if not proxy_url:
    raise ValueError("Set HASDATA_PROXY_URL")
response = requests.get(
    "https://httpbin.org/ip",
    proxies={"https": proxy_url},
    timeout=30,
)
response.raise_for_status()
print(response.text)

npm install axios https-proxy-agent

import axios from "axios";
import { HttpsProxyAgent } from "https-proxy-agent";

const response = await axios.get("https://httpbin.org/ip", {
  httpsAgent: new HttpsProxyAgent(process.env.HASDATA_PROXY_URL),
  proxy: false,
  timeout: 30_000,
});
console.log(response.data);

curl --fail --silent --show-error --max-time 30 \
  --noproxy "" \
  --proxy "${HASDATA_PROXY_URL:?Set HASDATA_PROXY_URL}" \
  https://httpbin.org/ip

PHP 8+ with cURL

<?php
$proxy = getenv('HASDATA_PROXY_URL') ?: throw new RuntimeException('Set HASDATA_PROXY_URL');
$ch = curl_init('https://httpbin.org/ip');
curl_setopt_array($ch, [
    CURLOPT_PROXY => $proxy,
    CURLOPT_NOPROXY => '',
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_FAILONERROR => true,
    CURLOPT_TIMEOUT => 30,
]);
$body = curl_exec($ch);
if ($body === false) {
    throw new RuntimeException(curl_error($ch));
}
echo $body;
curl_close($ch);

Standard library

package main

import (
    "io"
    "net/http"
    "net/url"
    "os"
    "time"
)

func main() {
    proxy, err := url.Parse(os.Getenv("HASDATA_PROXY_URL"))
    if err != nil { panic(err) }
    if proxy.Scheme != "http" || proxy.Host == "" { panic("Set HASDATA_PROXY_URL to an HTTP proxy URL") }

    transport := http.DefaultTransport.(*http.Transport).Clone()
    transport.Proxy = http.ProxyURL(proxy)
    client := &http.Client{Transport: transport, Timeout: 30 * time.Second}
    response, err := client.Get("https://httpbin.org/ip")
    if err != nil { panic(err) }
    defer response.Body.Close()
    if response.StatusCode != http.StatusOK { panic(response.Status) }
    if _, err := io.Copy(os.Stdout, response.Body); err != nil { panic(err) }
}

org.apache.httpcomponents.client5:httpclient5

import java.net.URI;
import org.apache.hc.client5.http.auth.*;
import org.apache.hc.client5.http.classic.methods.HttpGet;
import org.apache.hc.client5.http.impl.auth.BasicCredentialsProvider;
import org.apache.hc.client5.http.impl.classic.*;
import org.apache.hc.core5.http.HttpHost;

public class ProxyCheck {
    public static void main(String[] args) throws Exception {
        URI uri = URI.create(System.getenv("HASDATA_PROXY_URL"));
        HttpHost proxy = new HttpHost(uri.getScheme(), uri.getHost(), uri.getPort());
        var credentials = new BasicCredentialsProvider();
        if (uri.getUserInfo() != null) {
            String[] auth = uri.getUserInfo().split(":", 2);
            credentials.setCredentials(new AuthScope(proxy),
                new UsernamePasswordCredentials(auth[0], auth.length > 1 ? auth[1].toCharArray() : new char[0]));
        }
        try (var client = HttpClients.custom().setProxy(proxy)
                .setDefaultCredentialsProvider(credentials).build()) {
            System.out.println(client.execute(new HttpGet("https://httpbin.org/ip"),
                new BasicHttpClientResponseHandler()));
        }
    }
}

.NET 8+

using System.Net;

var uri = new Uri(Environment.GetEnvironmentVariable("HASDATA_PROXY_URL")
    ?? throw new InvalidOperationException("Set HASDATA_PROXY_URL"));
var proxy = new WebProxy(uri);
if (uri.UserInfo.Length > 0)
{
    var auth = uri.UserInfo.Split(':', 2);
    proxy.Credentials = new NetworkCredential(
        Uri.UnescapeDataString(auth[0]),
        auth.Length > 1 ? Uri.UnescapeDataString(auth[1]) : "");
}
using var handler = new HttpClientHandler { Proxy = proxy, UseProxy = true };
using var client = new HttpClient(handler) { Timeout = TimeSpan.FromSeconds(30) };
Console.WriteLine(await client.GetStringAsync("https://httpbin.org/ip"));

Standard library

require "net/http"
require "uri"

proxy = URI(ENV.fetch("HASDATA_PROXY_URL"))
raise "Set HASDATA_PROXY_URL to an HTTP proxy URL" unless proxy.scheme == "http" && proxy.host
target = URI("https://httpbin.org/ip")
decode = ->(value) { value && URI::DEFAULT_PARSER.unescape(value) }

response = Net::HTTP.start(
  target.host, target.port, proxy.host, proxy.port,
  decode.call(proxy.user), decode.call(proxy.password),
  use_ssl: true, open_timeout: 30, read_timeout: 30
) { |http| http.get(target.request_uri) }
response.value
puts response.body