#include <iostream>
#include <string>
#include <curl/curl.h>

// Callback function, used to process HTTP response data
size_t WriteCallback(void* contents, size_t size, size_t nmemb, std::string* s) {
    size_t newLength = size * nmemb;
    s->append((char*)contents, newLength);
    return newLength;
}

int main() {
    CURL* curl;
    CURLcode res;
    std::string readBuffer;

    // Initialize libcurl
    curl_global_init(CURL_GLOBAL_ALL);

    // Get a CURL handle
    curl = curl_easy_init();
    if(curl) {
        // Set proxy URL and port、username and password
        const char* proxyUrl = "http://Proxy URL:port";
        const char* proxyUserpwd = "username:password";
        curl_easy_setopt(curl, CURLOPT_PROXY, proxyUrl);
        curl_easy_setopt(curl, CURLOPT_PROXYUSERPWD, proxyUserpwd);

        // Set target URL
        curl_easy_setopt(curl, CURLOPT_URL, "http://ipinfo.io");

        // Set callback function to handle HTTP response data
        curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, WriteCallback);
        curl_easy_setopt(curl, CURLOPT_WRITEDATA, &readBuffer);

        // Execute HTTP requests
        res = curl_easy_perform(curl);

        // Check if the request was successful
        if(res != CURLE_OK) {
            std::cerr << "curl_easy_perform() failed: " << curl_easy_strerror(res) << std::endl;
        } else {
            // Print the return result
            std::cout << "Response:\n" << readBuffer << std::endl;
        }

        // clean
        curl_easy_cleanup(curl);
    }

    // clean
    curl_global_cleanup();

    return 0;
}
          

package main

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

var proxy_server = "http://Proxy URL:port"
var username = "username"
var password = "password"

func main() {
	// Set proxy URL
	proxyURL, err := url.Parse(proxy_server)
	if err != nil {
		fmt.Printf("Failed to parse proxy URL: %v\n", err)
		return
	}

	//
	proxyURL.User = url.UserPassword(username, password)

	// Create Transport
	transport := &http.Transport{
		Proxy: http.ProxyURL(proxyURL),
	}

	// Create client
	client := &http.Client{
		Transport: transport,
	}

	// Send request
	resp, err := client.Get("http://ipinfo.io")
	if err != nil {
		fmt.Printf("request failure: %v\n", err)
		return
	}
	defer resp.Body.Close()

	// Read response
	body, err := io.ReadAll(resp.Body)
	if err != nil {
		fmt.Printf("Read response fail: %v\n", err)
		return
	}

	// Output result
	fmt.Printf("status: %d\n", resp.StatusCode)
	fmt.Printf("Response content:\n%s\n", string(body))
}
          

#!/usr/bin/env node
require('request-promise')({
    url: 'https://ipinfo.io',
    proxy: 'http://???-zone-custom:????@us.proxy001.com:7878',
    })
.then(function(data){ console.log(data); },
    function(err){ console.error(err); });		       

// Target URL
$url = "http://ipinfo.io";

// Proxy server information
$proxy = "us.proxy001.com:7878"; // Replace with your proxy address and port
$proxyAuth = "username:password"; //  Replace with agent username and password

// Initialize cURL
$ch = curl_init();
curl_setopt($ch, CURLOPT_PROXY, $proxy );
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyAuth);
curl_setopt($ch, CURLOPT_PROXYTYPE,CURLPROXY_HTTP);
curl_setopt($ch, CURLOPT_URL, $url);
curl_setopt($ch, CURLOPT_TIMEOUT, 30);
$result = curl_exec($ch);
curl_close($ch);
echo $result;
          

import org.apache.http.HttpHost;
import org.apache.http.HttpResponse;
import org.apache.http.auth.AuthScope;
import org.apache.http.auth.UsernamePasswordCredentials;
import org.apache.http.client.CredentialsProvider;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.BasicCredentialsProvider;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;

public class auth_demo {
    public static void main(String[] args) {
        String proxyHost = "Proxy ip";
        int proxyPort = 7878;
        String proxyUsername = "username";
        String proxyPassword = "password";
        String targetUrl = "http://ipinfo.io";

        //
        CredentialsProvider credsProvider = new BasicCredentialsProvider();
        credsProvider.setCredentials(
                new AuthScope(proxyHost, proxyPort),
                new UsernamePasswordCredentials(proxyUsername, proxyPassword));

        //
        try (CloseableHttpClient httpClient = HttpClients.custom()
                .setDefaultCredentialsProvider(credsProvider)
                .setProxy(new HttpHost(proxyHost, proxyPort))
                .build()) {

            //
            HttpGet httpGet = new HttpGet(targetUrl);

            //
            HttpResponse response = httpClient.execute(httpGet);

            //
            int statusCode = response.getStatusLine().getStatusCode();
            if (statusCode == 200) {
                //
                String responseBody = EntityUtils.toString(response.getEntity());
                System.out.println("response:\n" + responseBody);
            } else {
                System.out.println("request failed, status code: " + statusCode);
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}
          

import requests

        # Target URL
        url = "http://ipinfo.io"

        proxyserver = "http://Proxy ip:port"#如us.proxy001.com:7878
        username = "username"
        password = "password"

        # Proxy settings
        proxies = {
        }

        try:
            # Send GET request
            response = requests.get(url, proxies=proxies)

            # Check the response status
            response.raise_for_status()

            # Print the return result
            print(response.text)
        except requests.exceptions.RequestException as e:
            # Handling request exceptions
            print(f"request failure: {e}")