Advanced Settings

This page covers advanced configuration options for AdminCloud proxy to help you optimize performance, improve stability, and implement more complex features.

Session Management

Session Persistence

Maintain the same IP address through session ID:

# Add session ID
curl -x gtx.paopaous.net:38082 \
  --proxy-user "myuser:ip:res-c:US:sid-12345:your_password_here" \
  -L https://httpbin.org/ip

Session Parameters

Parameter	Description	Example
sid	Session identifier	sid-
12345	Custom string	Any alphanumeric combination

Programming Implementation

Python Session Management

import requests
import uuid

class ProxySession:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
        self.session_id = str(uuid.uuid4())[:8]
    
    def get_proxies(self):
        proxy_user = f"{self.username}:ip:res-c:{self.country}:sid-{self.session_id}"
        return {
            "http": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082",
            "https": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082"
        }
    
    def test_session(self):
        proxies = self.get_proxies()
        response = requests.get("https://httpbin.org/ip", proxies=proxies)
        return response.json()['origin']

# Usage example
session = ProxySession("myuser", "your_password_here", "US")

# Test session persistence
for i in range(3):
    ip = session.test_session()
    print(f"Request {i+1}: {ip}")

Node.js Session Management

const axios = require('axios');
const { v4: uuidv4 } = require('uuid');

class ProxySession {
    constructor(username, password, country = 'US') {
        this.username = username;
        this.password = password;
        this.country = country;
        this.sessionId = uuidv4().substring(0, 8);
    }
    
    getProxyConfig() {
        const proxyUser = `${this.username}:ip:res-c:${this.country}:sid-${this.sessionId}`;
        return {
            protocol: 'http',
            host: 'gtx.paopaous.net',
            port: 38082,
            auth: {
                username: proxyUser,
                password: this.password
            }
        };
    }
    
    async testSession() {
        const proxyConfig = this.getProxyConfig();
        const response = await axios.get('https://httpbin.org/ip', { proxy: proxyConfig });
        return response.data.origin;
    }
}

// Usage example
const session = new ProxySession('myuser', 'your_password_here', 'US');

for (let i = 0; i < 3; i++) {
    session.testSession().then(ip => {
        console.log(`Request ${i + 1}: ${ip}`);
    });
}

Connection Pool Optimization

Python Connection Pool

import requests
from requests.adapters import HTTPAdapter
from urllib3.util.retry import Retry

class OptimizedProxyClient:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
        self.session = self._create_session()
    
    def _create_session(self):
        session = requests.Session()
        
        # Configure retry strategy
        retry_strategy = Retry(
            total=3,
            backoff_factor=1,
            status_forcelist=[429, 500, 502, 503, 504]
        )
        
        # Configure adapter
        adapter = HTTPAdapter(
            max_retries=retry_strategy,
            pool_connections=20,
            pool_maxsize=50
        )
        
        session.mount("http://", adapter)
        session.mount("https://", adapter)
        
        return session
    
    def get_proxies(self):
        proxy_user = f"{self.username}:ip:res-c:{self.country}"
        return {
            "http": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082",
            "https": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082"
        }
    
    def request(self, method, url, **kwargs):
        kwargs.setdefault('proxies', self.get_proxies())
        kwargs.setdefault('timeout', (10, 30))
        return self.session.request(method, url, **kwargs)

# Usage example
client = OptimizedProxyClient("myuser", "your_password_here", "US")

for i in range(10):
    response = client.request("GET", "https://httpbin.org/ip")
    print(f"Request {i+1}: {response.json()['origin']}")

Node.js Connection Pool

const axios = require('axios');
const { Pool } = require('agentkeepalive');

class OptimizedProxyClient {
    constructor(username, password, country = 'US') {
        this.username = username;
        this.password = password;
        this.country = country;
        this.axiosInstance = this._createAxiosInstance();
    }
    
    _createAxiosInstance() {
        const httpsAgent = new Pool({
            maxSockets: 50,
            maxFreeSockets: 10,
            timeout: 30000,
            freeSocketTimeout: 30000
        });
        
        const proxyConfig = {
            protocol: 'http',
            host: 'gtx.paopaous.net',
            port: 38082,
            auth: {
                username: `${this.username}:ip:res-c:${this.country}`,
                password: this.password
            }
        };
        
        return axios.create({
            proxy: proxyConfig,
            httpsAgent,
            timeout: 30000
        });
    }
    
    async request(method, url, options = {}) {
        try {
            const response = await this.axiosInstance.request({
                method,
                url,
                ...options
            });
            return response;
        } catch (error) {
            console.error('Request failed:', error.message);
            throw error;
        }
    }
}

// Usage example
const client = new OptimizedProxyClient('myuser', 'your_password_here', 'US');

for (let i = 0; i < 10; i++) {
    client.request('GET', 'https://httpbin.org/ip')
        .then(response => console.log(`Request ${i + 1}: ${response.data.origin}`))
        .catch(error => console.error(error));
}

Rotation Strategies

Automatic Rotation

By default, each request uses a different IP:

import requests

proxies = {
    "http": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082",
    "https": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082"
}

# Each request uses different IP
for i in range(5):
    response = requests.get("https://httpbin.org/ip", proxies=proxies)
    print(f"Request {i+1}: {response.json()['origin']}")

Time-Controlled Rotation

import time
import requests

def timed_rotation():
    proxies = {
        "http": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082",
        "https": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082"
    }
    
    start_time = time.time()
    rotation_interval = 60  # Rotate every 60 seconds
    
    while time.time() - start_time < 300:  # Run for 5 minutes
        response = requests.get("https://httpbin.org/ip", proxies=proxies)
        current_ip = response.json()['origin']
        print(f"Current IP: {current_ip}")
        
        time.sleep(10)  # Check every 10 seconds

timed_rotation()

Conditional Rotation

import requests
import random

def conditional_rotation():
    proxies = {
        "http": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082",
        "https": "http://myuser:ip:res-c:US:your_password_here@gtx.paopaous.net:38082"
    }
    
    current_ip = None
    request_count = 0
    
    while request_count < 20:
        response = requests.get("https://httpbin.org/ip", proxies=proxies)
        new_ip = response.json()['origin']
        
        if new_ip != current_ip:
            print(f"IP rotation: {current_ip} → {new_ip}")
            current_ip = new_ip
        
        request_count += 1
        
        # Random delay to simulate real user behavior
        delay = random.uniform(1, 5)
        time.sleep(delay)

conditional_rotation()

Error Handling & Retry

Exponential Backoff Retry

import time
import requests
from functools import wraps

def retry_with_backoff(max_retries=3, base_delay=1, max_delay=60):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            for attempt in range(max_retries):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    if attempt == max_retries - 1:
                        raise e
                    
                    delay = min(base_delay * (2 ** attempt), max_delay)
                    print(f"Request failed, retrying in {delay} seconds... (Attempt {attempt + 1}/{max_retries})")
                    time.sleep(delay)
            
            return None
        return wrapper
    return decorator

class RobustProxyClient:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
    
    def get_proxies(self):
        proxy_user = f"{self.username}:ip:res-c:{self.country}"
        return {
            "http": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082",
            "https": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082"
        }
    
    @retry_with_backoff(max_retries=3, base_delay=2)
    def get(self, url, **kwargs):
        kwargs.setdefault('proxies', self.get_proxies())
        kwargs.setdefault('timeout', 30)
        return requests.get(url, **kwargs)

# Usage example
client = RobustProxyClient("myuser", "your_password_here", "US")

try:
    response = client.get("https://httpbin.org/ip")
    print(f"Request successful: {response.json()['origin']}")
except Exception as e:
    print(f"Request ultimately failed: {e}")

Smart Error Classification

import requests
from enum import Enum

class ErrorType(Enum):
    NETWORK_ERROR = "network"
    AUTH_ERROR = "auth"
    PROXY_ERROR = "proxy"
    RATE_LIMIT = "rate_limit"
    SERVER_ERROR = "server"

class SmartProxyClient:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
    
    def classify_error(self, error):
        if isinstance(error, requests.exceptions.ConnectionError):
            return ErrorType.NETWORK_ERROR
        elif isinstance(error, requests.exceptions.ProxyError):
            return ErrorType.AUTH_ERROR
        elif isinstance(error, requests.exceptions.Timeout):
            return ErrorType.PROXY_ERROR
        elif hasattr(error, 'response') and error.response.status_code == 429:
            return ErrorType.RATE_LIMIT
        elif hasattr(error, 'response') and error.response.status_code >= 500:
            return ErrorType.SERVER_ERROR
        else:
            return ErrorType.NETWORK_ERROR
    
    def handle_error(self, error_type):
        handlers = {
            ErrorType.NETWORK_ERROR: self._handle_network_error,
            ErrorType.AUTH_ERROR: self._handle_auth_error,
            ErrorType.PROXY_ERROR: self._handle_proxy_error,
            ErrorType.RATE_LIMIT: self._handle_rate_limit,
            ErrorType.SERVER_ERROR: self._handle_server_error
        }
        
        return handlers.get(error_type, self._handle_generic_error)
    
    def _handle_network_error(self):
        print("Network error, check network connection")
        return 2  # Retry interval 2 seconds
    
    def _handle_auth_error(self):
        print("Authentication error, check username and password")
        return 0  # Don't retry
    
    def _handle_proxy_error(self):
        print("Proxy error, retry later")
        return 5  # Retry interval 5 seconds
    
    def _handle_rate_limit(self):
        print("Rate limit exceeded, extend retry interval")
        return 60  # Retry interval 60 seconds
    
    def _handle_server_error(self):
        print("Server error, retry later")
        return 10  # Retry interval 10 seconds
    
    def _handle_generic_error(self):
        print("Unknown error, using default retry strategy")
        return 3  # Retry interval 3 seconds
    
    def request_with_smart_retry(self, url, max_retries=3):
        for attempt in range(max_retries):
            try:
                proxies = {
                    "http": f"http://{self.username}:ip:res-c:{self.country}:{self.password}@gtx.paopaous.net:38082",
                    "https": f"http://{self.username}:ip:res-c:{self.country}:{self.password}@gtx.paopaous.net:38082"
                }
                
                response = requests.get(url, proxies=proxies, timeout=30)
                return response
            
            except Exception as e:
                error_type = self.classify_error(e)
                retry_delay = self.handle_error(error_type)
                
                if attempt == max_retries - 1 or retry_delay == 0:
                    raise e
                
                print(f"Waiting {retry_delay} seconds before retrying...")
                time.sleep(retry_delay)

# Usage example
client = SmartProxyClient("myuser", "your_password_here", "US")

try:
    response = client.request_with_smart_retry("https://httpbin.org/ip")
    print(f"Request successful: {response.json()['origin']}")
except Exception as e:
    print(f"Request failed: {e}")

Performance Monitoring

Response Time Monitoring

import time
import requests
from statistics import mean, median

class PerformanceMonitor:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
        self.response_times = []
    
    def get_proxies(self):
        proxy_user = f"{self.username}:ip:res-c:{self.country}"
        return {
            "http": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082",
            "https": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082"
        }
    
    def timed_request(self, url):
        start_time = time.time()
        
        try:
            response = requests.get(url, proxies=self.get_proxies(), timeout=30)
            end_time = time.time()
            
            response_time = end_time - start_time
            self.response_times.append(response_time)
            
            return {
                'success': True,
                'response_time': response_time,
                'status_code': response.status_code,
                'ip': response.json()['origin']
            }
        except Exception as e:
            end_time = time.time()
            response_time = end_time - start_time
            
            return {
                'success': False,
                'response_time': response_time,
                'error': str(e)
            }
    
    def run_performance_test(self, url, requests_count=50):
        print(f"Starting performance test, {requests_count} requests total...")
        
        results = []
        for i in range(requests_count):
            result = self.timed_request(url)
            results.append(result)
            
            status = "✅" if result['success'] else "❌"
            print(f"Request {i+1}: {status} - {result['response_time']:.2f}s")
            
            time.sleep(0.1)  # Avoid too frequent requests
        
        self.print_statistics(results)
        return results
    
    def print_statistics(self, results):
        successful_results = [r for r in results if r['success']]
        failed_results = [r for r in results if not r['success']]
        
        if successful_results:
            response_times = [r['response_time'] for r in successful_results]
            
            print("\n=== Performance Statistics ===")
            print(f"Successful requests: {len(successful_results)}/{len(results)}")
            print(f"Failed requests: {len(failed_results)}")
            print(f"Success rate: {len(successful_results)/len(results)*100:.1f}%")
            print(f"Average response time: {mean(response_times):.2f}s")
            print(f"Median response time: {median(response_times):.2f}s")
            print(f"Fastest response time: {min(response_times):.2f}s")
            print(f"Slowest response time: {max(response_times):.2f}s")
        
        if failed_results:
            print(f"\n=== Failure Reasons ===")
            error_counts = {}
            for result in failed_results:
                error = result.get('error', 'Unknown')
                error_counts[error] = error_counts.get(error, 0) + 1
            
            for error, count in error_counts.items():
                print(f"{error}: {count} times")

# Usage example
monitor = PerformanceMonitor("myuser", "your_password_here", "US")
results = monitor.run_performance_test("https://httpbin.org/ip", 20)

Concurrency Performance Testing

import concurrent.futures
import time
import requests

class ConcurrencyTester:
    def __init__(self, username, password, country="US"):
        self.username = username
        self.password = password
        self.country = country
    
    def get_proxies(self):
        proxy_user = f"{self.username}:ip:res-c:{self.country}"
        return {
            "http": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082",
            "https": f"http://{proxy_user}:{self.password}@gtx.paopaous.net:38082"
        }
    
    def single_request(self, url, request_id):
        start_time = time.time()
        
        try:
            response = requests.get(url, proxies=self.get_proxies(), timeout=30)
            end_time = time.time()
            
            return {
                'request_id': request_id,
                'success': True,
                'response_time': end_time - start_time,
                'ip': response.json()['origin']
            }
        except Exception as e:
            end_time = time.time()
            
            return {
                'request_id': request_id,
                'success': False,
                'response_time': end_time - start_time,
                'error': str(e)
            }
    
    def test_concurrency(self, url, concurrent_users=5, requests_per_user=10):
        print(f"Concurrency test: {concurrent_users} concurrent users, {requests_per_user} requests per user")
        
        total_requests = concurrent_users * requests_per_user
        all_results = []
        
        start_time = time.time()
        
        with concurrent.futures.ThreadPoolExecutor(max_workers=concurrent_users) as executor:
            # Create request tasks for each user
            futures = []
            for user_id in range(concurrent_users):
                for req_id in range(requests_per_user):
                    request_id = f"user{user_id}-req{req_id}"
                    future = executor.submit(self.single_request, url, request_id)
                    futures.append(future)
            
            # Collect results
            for future in concurrent.futures.as_completed(futures):
                result = future.result()
                all_results.append(result)
                
                status = "✅" if result['success'] else "❌"
                print(f"{status} {result['request_id']}: {result['response_time']:.2f}s")
        
        end_time = time.time()
        total_time = end_time - start_time
        
        self.print_concurrency_stats(all_results, total_time)
        return all_results
    
    def print_concurrency_stats(self, results, total_time):
        successful_results = [r for r in results if r['success']]
        failed_results = [r for r in results if not r['success']]
        
        print("\n=== Concurrency Performance Statistics ===")
        print(f"Total requests: {len(results)}")
        print(f"Total time: {total_time:.2f}s")
        print(f"Successful requests: {len(successful_results)}")
        print(f"Failed requests: {len(failed_results)}")
        print(f"Success rate: {len(successful_results)/len(results)*100:.1f}%")
        print(f"QPS (requests per second): {len(results)/total_time:.2f}")
        
        if successful_results:
            response_times = [r['response_time'] for r in successful_results]
            print(f"Average response time: {mean(response_times):.2f}s")
            print(f"Fastest response time: {min(response_times):.2f}s")
            print(f"Slowest response time: {max(response_times):.2f}s")

# Usage example
tester = ConcurrencyTester("myuser", "your_password_here", "US")
results = tester.test_concurrency("https://httpbin.org/ip", concurrent_users=3, requests_per_user=5)

---

Configuration complete! View more proxy configuration information.