The Essential Guide to the Top 5 Datacenter Proxy Providers

import requests

# Simple API call with WebScraping.AI
response = requests.get(
    'https://api.webscraping.ai/v1',
    params={
        'url': 'https://example.com/products',
        'api_key': 'YOUR_API_KEY',
        'render_js': True,
        'proxy_type': 'datacenter',
        'return_format': 'json'
    }
)

data = response.json()
print(data['products'])

import requests
from requests.auth import HTTPProxyAuth

# Configure proxy authentication
proxy_auth = HTTPProxyAuth('username', 'password')

# Set up proxy connection
proxies = {
    'http': 'http://dc.smartproxy.com:10000',
    'https': 'http://dc.smartproxy.com:10000'
}

# Make request through datacenter proxy
response = requests.get(
    'https://example.com/api/data',
    proxies=proxies,
    auth=proxy_auth,
    headers={
        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'
    }
)

print(response.json())

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

// Configure BrightData datacenter proxy
const proxyConfig = {
    host: 'zproxy.lum-superproxy.io',
    port: 22225,
    auth: {
        username: 'lum-customer-USERNAME-zone-datacenter',
        password: 'PASSWORD'
    }
};

// Create proxy agent
const agent = new HttpsProxyAgent(
    `http://${proxyConfig.auth.username}:${proxyConfig.auth.password}@${proxyConfig.host}:${proxyConfig.port}`
);

// Make request through proxy
async function scrapeWithBrightData() {
    try {
        const response = await axios.get('https://example.com/api/products', {
            httpAgent: agent,
            httpsAgent: agent,
            headers: {
                'User-Agent': 'Mozilla/5.0 (compatible; DataBot/1.0)'
            }
        });

        console.log(response.data);
    } catch (error) {
        console.error('Scraping error:', error.message);
    }
}

scrapeWithBrightData();

require 'net/http'
require 'uri'

# ProxyRack configuration
proxy_host = 'premium.proxyrack.net'
proxy_port = 10000
proxy_user = 'username'
proxy_pass = 'password'

# Target URL
uri = URI('https://example.com/data.json')

# Configure proxy connection
Net::HTTP.start(uri.host, uri.port,
  :proxy_addr => proxy_host,
  :proxy_port => proxy_port,
  :proxy_user => proxy_user,
  :proxy_pass => proxy_pass,
  :use_ssl => uri.scheme == 'https'
) do |http|
  request = Net::HTTP::Get.new(uri)
  request['User-Agent'] = 'Mozilla/5.0 (compatible; ProxyRack/1.0)'

  response = http.request(request)
  puts response.body
end

<?php
// Storm Proxies configuration
$proxy = 'server.stormproxies.cn:6000';
$proxyAuth = 'username:password';

// Initialize cURL
$ch = curl_init();

// Set cURL options
curl_setopt($ch, CURLOPT_URL, 'https://example.com/api/data');
curl_setopt($ch, CURLOPT_PROXY, $proxy);
curl_setopt($ch, CURLOPT_PROXYUSERPWD, $proxyAuth);
curl_setopt($ch, CURLOPT_PROXYTYPE, CURLPROXY_HTTP);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($ch, CURLOPT_HTTPHEADER, [
    'User-Agent: Mozilla/5.0 (compatible; StormBot/1.0)'
]);

// Execute request
$response = curl_exec($ch);
$error = curl_error($ch);
curl_close($ch);

if ($error) {
    echo "Error: " . $error;
} else {
    $data = json_decode($response, true);
    print_r($data);
}
?>

import time
import requests
from typing import List

class ProxyRotator:
    def __init__(self, proxies: List[str], delay: float = 1.0):
        self.proxies = proxies
        self.delay = delay
        self.current_index = 0

    def get_next_proxy(self):
        proxy = self.proxies[self.current_index]
        self.current_index = (self.current_index + 1) % len(self.proxies)
        return proxy

    def scrape_with_rotation(self, urls: List[str]):
        results = []
        for url in urls:
            proxy = self.get_next_proxy()
            try:
                response = requests.get(
                    url,
                    proxies={'http': proxy, 'https': proxy},
                    timeout=10
                )
                results.append(response.text)
            except Exception as e:
                print(f"Error with {url}: {e}")
                results.append(None)

            time.sleep(self.delay)  # Rate limiting

        return results

class ProxyManager {
    constructor(proxyList) {
        this.proxies = proxyList;
        this.failedProxies = new Set();
        this.maxRetries = 3;
    }

    async fetchWithRetry(url, options = {}) {
        let lastError;

        for (let i = 0; i < this.maxRetries; i++) {
            const proxy = this.getWorkingProxy();
            if (!proxy) {
                throw new Error('No working proxies available');
            }

            try {
                const response = await fetch(url, {
                    ...options,
                    agent: new HttpsProxyAgent(proxy)
                });

                if (response.ok) {
                    return response;
                }

                // Mark proxy as failed on 4xx/5xx responses
                if (response.status >= 400) {
                    this.markProxyFailed(proxy);
                }
            } catch (error) {
                lastError = error;
                this.markProxyFailed(proxy);
            }
        }

        throw lastError || new Error('Max retries exceeded');
    }

    getWorkingProxy() {
        const availableProxies = this.proxies.filter(
            p => !this.failedProxies.has(p)
        );

        if (availableProxies.length === 0) {
            // Reset failed proxies if all are marked as failed
            this.failedProxies.clear();
            return this.proxies[0];
        }

        return availableProxies[
            Math.floor(Math.random() * availableProxies.length)
        ];
    }

    markProxyFailed(proxy) {
        this.failedProxies.add(proxy);
    }
}

import time
import statistics
from dataclasses import dataclass
from typing import Dict, List

@dataclass
class ProxyMetrics:
    total_requests: int = 0
    successful_requests: int = 0
    failed_requests: int = 0
    response_times: List[float] = None

    def __post_init__(self):
        if self.response_times is None:
            self.response_times = []

    @property
    def success_rate(self) -> float:
        if self.total_requests == 0:
            return 0.0
        return self.successful_requests / self.total_requests

    @property
    def average_response_time(self) -> float:
        if not self.response_times:
            return 0.0
        return statistics.mean(self.response_times)

class ProxyMonitor:
    def __init__(self):
        self.metrics: Dict[str, ProxyMetrics] = {}

    def record_request(self, proxy: str, success: bool, response_time: float):
        if proxy not in self.metrics:
            self.metrics[proxy] = ProxyMetrics()

        metrics = self.metrics[proxy]
        metrics.total_requests += 1

        if success:
            metrics.successful_requests += 1
            metrics.response_times.append(response_time)
        else:
            metrics.failed_requests += 1

    def get_best_proxies(self, top_n: int = 5) -> List[str]:
        """Return proxies sorted by success rate and response time"""
        proxy_scores = []

        for proxy, metrics in self.metrics.items():
            if metrics.total_requests < 10:  # Minimum sample size
                continue

            # Score based on success rate (70%) and speed (30%)
            score = (metrics.success_rate * 0.7) + \
                    ((1 / max(metrics.average_response_time, 0.1)) * 0.3)

            proxy_scores.append((proxy, score))

        proxy_scores.sort(key=lambda x: x[1], reverse=True)
        return [proxy for proxy, _ in proxy_scores[:top_n]]