Free Trial Residential Proxy Servers

// Using fetch with a proxy agent (Node.js)
import { HttpsProxyAgent } from 'https-proxy-agent';

const proxyUrl = 'http://USERNAME:PASSWORD@proxy-staging.weproxies.com:1080';
const agent = new HttpsProxyAgent(proxyUrl);

// Basic request
const response = await fetch('https://httpbin.org/ip', { agent });
const data = await response.json();
console.log(data);

// With country targeting (US)
const proxyUs = 'http://USERNAME-country-us:PASSWORD@proxy-staging.weproxies.com:1080';
const agentUs = new HttpsProxyAgent(proxyUs);
const responseUs = await fetch('https://httpbin.org/ip', { agent: agentUs });

// With sticky session
const proxySticky = 'http://USERNAME-sessionid-mysession:PASSWORD@proxy-staging.weproxies.com:1080';
const agentSticky = new HttpsProxyAgent(proxySticky);
const responseSticky = await fetch('https://httpbin.org/ip', { agent: agentSticky });

package main

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

func main() {
    // Proxy configuration
    proxyURL, _ := url.Parse("http://USERNAME:PASSWORD@proxy-staging.weproxies.com:1080")
    
    client := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
        },
    }

    // Basic request
    resp, err := client.Get("https://httpbin.org/ip")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    body, _ := io.ReadAll(resp.Body)
    fmt.Println(string(body))

    // With country targeting (US)
    proxyUS, _ := url.Parse("http://USERNAME-country-us:PASSWORD@proxy-staging.weproxies.com:1080")
    clientUS := &http.Client{
        Transport: &http.Transport{
            Proxy: http.ProxyURL(proxyUS),
        },
    }
    respUS, _ := clientUS.Get("https://httpbin.org/ip")
    defer respUS.Body.Close()
}

import java.net.*;
import java.io.*;

public class ProxyExample {
    public static void main(String[] args) throws Exception {
        // Proxy configuration
        String proxyHost = "proxy-staging.weproxies.com";
        int proxyPort = 1080;
        String proxyUser = "USERNAME";
        String proxyPass = "PASSWORD";

        // Set proxy authentication
        Authenticator.setDefault(new Authenticator() {
            @Override
            protected PasswordAuthentication getPasswordAuthentication() {
                return new PasswordAuthentication(proxyUser, proxyPass.toCharArray());
            }
        });

        // Create proxy
        Proxy proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort));

        // Basic request
        URL url = new URL("https://httpbin.org/ip");
        HttpURLConnection conn = (HttpURLConnection) url.openConnection(proxy);
        
        BufferedReader reader = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        String line;
        while ((line = reader.readLine()) != null) {
            System.out.println(line);
        }
        reader.close();

        // With country targeting - change username to: USERNAME-country-us
        // With sticky session - change username to: USERNAME-sessionid-mysession
    }
}

using System;
using System.Net;
using System.Net.Http;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        // Proxy configuration
        var proxy = new WebProxy("proxy-staging.weproxies.com", 1080)
        {
            Credentials = new NetworkCredential("USERNAME", "PASSWORD")
        };

        var handler = new HttpClientHandler
        {
            Proxy = proxy,
            UseProxy = true
        };

        using var client = new HttpClient(handler);

        // Basic request
        var response = await client.GetStringAsync("https://httpbin.org/ip");
        Console.WriteLine(response);

        // With country targeting (US)
        var proxyUS = new WebProxy("proxy-staging.weproxies.com", 1080)
        {
            Credentials = new NetworkCredential("USERNAME-country-us", "PASSWORD")
        };

        // With sticky session
        var proxySticky = new WebProxy("proxy-staging.weproxies.com", 1080)
        {
            Credentials = new NetworkCredential("USERNAME-sessionid-mysession", "PASSWORD")
        };
    }
}

<?php
// Proxy configuration
$proxyUrl = 'http://USERNAME:PASSWORD@proxy-staging.weproxies.com:1080';

// Using cURL
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://httpbin.org/ip');
curl_setopt($ch, CURLOPT_PROXY, 'proxy-staging.weproxies.com:1080');
curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'USERNAME:PASSWORD');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);
echo $response;

// With country targeting (US)
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://httpbin.org/ip');
curl_setopt($ch, CURLOPT_PROXY, 'proxy-staging.weproxies.com:1080');
curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'USERNAME-country-us:PASSWORD');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);

$response = curl_exec($ch);
curl_close($ch);

// With sticky session
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'https://httpbin.org/ip');
curl_setopt($ch, CURLOPT_PROXY, 'proxy-staging.weproxies.com:1080');
curl_setopt($ch, CURLOPT_PROXYUSERPWD, 'USERNAME-sessionid-mysession:PASSWORD');
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);

// Using Guzzle
use GuzzleHttp\Client;

$client = new Client([
    'proxy' => $proxyUrl
]);

$response = $client->get('https://httpbin.org/ip');
echo $response->getBody();
?>