SOCKS5 API Documentation & Integration Guide

import requests

proxies = {
    "http": "socks5://username:[email protected]:1080",
    "https": "socks5://username:[email protected]:1080"
}

response = requests.get("https://api.ipify.org", proxies=proxies)
print(f"Your proxy IP: {response.text}")

import aiohttp
import asyncio

async def fetch_with_proxy():
    proxy = "socks5://username:[email protected]:1080"
    connector = aiohttp.TCPConnector()
    
    async with aiohttp.ClientSession(connector=connector) as session:
        async with session.get("https://api.ipify.org", proxy=proxy) as response:
            return await response.text()

# Run the async function
print(asyncio.run(fetch_with_proxy()))

const axios = require("axios");
const { SocksProxyAgent } = require("socks-proxy-agent");

const proxyAgent = new SocksProxyAgent(
  "socks5://username:[email protected]:1080"
);

axios.get("https://api.ipify.org", {
  httpsAgent: proxyAgent,
  httpAgent: proxyAgent
})
.then(response => {
  console.log(`Your proxy IP: ${response.data}`);
});

const puppeteer = require("puppeteer");

async function run() {
  const browser = await puppeteer.launch({
    args: [
      "--proxy-server=socks5://proxy.gatewaypay.online:1080",
      "--disable-features=VizDisplayCompositor"
    ]
  });
  
  const page = await browser.newPage();
  await page.authenticate({
    username: "your-username",
    password: "your-password"
  });
  
  await page.goto("https://api.ipify.org");
  const content = await page.content();
  console.log(content);
  
  await browser.close();
}

run();

import org.apache.http.HttpHost;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClients;
import java.net.InetSocketAddress;
import java.net.Proxy;

// Create SOCKS5 proxy
Proxy proxy = new Proxy(Proxy.Type.SOCKS, 
    new InetSocketAddress("proxy.gatewaypay.online", 1080));

// Create HttpClient with proxy
CloseableHttpClient httpClient = HttpClients.custom()
    .setProxy(new HttpHost("proxy.gatewaypay.online", 1080, "http"))
    .build();

HttpGet request = new HttpGet("https://api.ipify.org");
String response = httpClient.execute(request, responseHandler);
System.out.println("Your proxy IP: " + response);

// Using SOCKS5 with authentication
import java.net.Authenticator;
import java.net.PasswordAuthentication;

Authenticator.setDefault(new Authenticator() {
    @Override
    protected PasswordAuthentication getPasswordAuthentication() {
        return new PasswordAuthentication(
            "username", 
            "password".toCharArray()
        );
    }
});

// Set system properties for SOCKS5
System.setProperty("socksProxyHost", "proxy.gatewaypay.online");
System.setProperty("socksProxyPort", "1080");
System.setProperty("java.net.socks.username", "username");
System.setProperty("java.net.socks.password", "password");

package main

import (
    "fmt"
    "net/http"
    "golang.org/x/net/proxy"
)

func main() {
    // Create SOCKS5 dialer
    dialer, err := proxy.SOCKS5("tcp", 
        "proxy.gatewaypay.online:1080", 
        &proxy.Auth{
            User: "username",
            Password: "password",
        },
        proxy.Direct,
    )
    
    if err != nil {
        panic(err)
    }
    
    // Create HTTP transport
    httpTransport := &http.Transport{Dial: dialer.Dial}
    httpClient := &http.Client{Transport: httpTransport}
    
    resp, err := httpClient.Get("https://api.ipify.org")
    // Handle response
}

// Concurrent requests with SOCKS5 proxy in Go
package main

import (
    "fmt"
    "sync"
    "golang.org/x/net/proxy"
    "net/http"
)

func worker(proxyURL string, wg *sync.WaitGroup, results chan<- string) {
    defer wg.Done()
    
    dialer, _ := proxy.SOCKS5("tcp", proxyURL, nil, proxy.Direct)
    httpTransport := &http.Transport{Dial: dialer.Dial}
    client := &http.Client{Transport: httpTransport}
    
    resp, _ := client.Get("https://api.ipify.org")
    // Process response
    results <- "Request completed"
}

func main() {
    var wg sync.WaitGroup
    results := make(chan string, 10)
    
    for i := 0; i < 5; i++ {
        wg.Add(1)
        go worker("proxy.gatewaypay.online:1080", &wg, results)
    }
    
    wg.Wait()
    close(results)
}

curl --socks5-hostname proxy.gatewaypay.online:1080 \
     --proxy-user username:password \
     https://api.ipify.org

# Multiple requests with SOCKS5 proxy
curl --socks5-hostname proxy.gatewaypay.online:1080 \
     --proxy-user username:password \
     --parallel \
     --parallel-max 5 \
     --url "https://api.ipify.org" \
     --url "https://httpbin.org/ip" \
     --url "https://ifconfig.me/ip"

# With session persistence (sticky sessions)
curl --socks5-hostname proxy.gatewaypay.online:1080 \
     --proxy-user username:password \
     --cookie-jar cookies.txt \
     --cookie cookies.txt \
     https://example.com