# Test proxy via command line
curl --proxy http://proxy.example.com:8080 https://ipinfo.io

# With authentication
curl --proxy http://username:[email protected]:8080 https://ipinfo.io

# Pretty JSON output
curl --proxy http://proxy.example.com:8080 https://ipinfo.io/json | python -m json.tool

{
  "ip": "203.0.113.45",
  "city": "Los Angeles",
  "region": "California",
  "country": "US",
  "org": "AS7922 Comcast Cable Communications",
  "timezone": "America/Los_Angeles"
}

import requests

def test_proxy_with_ipinfo(proxy):
    """Test single proxy with IPinfo.io"""
    proxies = {
        'http': proxy,
        'https': proxy
    }
    
    try:
        response = requests.get(
            'https://ipinfo.io/json',
            proxies=proxies,
            timeout=10
        )
        
        if response.status_code == 200:
            data = response.json()
            return {
                'proxy': proxy,
                'status': 'working',
                'ip': data.get('ip'),
                'city': data.get('city'),
                'country': data.get('country'),
                'org': data.get('org')
            }
    except Exception as e:
        return {
            'proxy': proxy,
            'status': 'failed',
            'error': str(e)
        }

# Test multiple proxies
proxy_list = [
    'http://proxy1.example.com:8080',
    'http://proxy2.example.com:8080',
    'http://proxy3.example.com:8080'
]

for proxy in proxy_list:
    result = test_proxy_with_ipinfo(proxy)
    print(f"{result['proxy']}: {result['status']}")
    if result['status'] == 'working':
        print(f"  IP: {result['ip']}, Location: {result['city']}, {result['country']}")

import requests

def check_ip_with_ip2location(ip_address, api_key):
    """Check IP details with IP2Location API"""
    url = f"https://api.ip2location.com/v2/?ip={ip_address}&key={api_key}&package=WS24"
    
    try:
        response = requests.get(url, timeout=10)
        data = response.json()
        
        return {
            'ip': ip_address,
            'country': data.get('country_name'),
            'city': data.get('city_name'),
            'isp': data.get('isp'),
            'proxy_type': data.get('proxy_type'),
            'is_proxy': data.get('is_proxy') == 'YES',
            'usage_type': data.get('usage_type')
        }
    except Exception as e:
        return {'ip': ip_address, 'error': str(e)}

# Usage
api_key = "YOUR_API_KEY"
result = check_ip_with_ip2location("8.8.8.8", api_key)
print(result)

import requests

def check_ip_with_ipqs(ip_address, api_key):
    """Check IP reputation with IPQualityScore"""
    url = f"https://ipqualityscore.com/api/json/ip/{api_key}/{ip_address}"
    
    params = {
        'strictness': 1,  # 0-2, higher = more strict
        'allow_public_access_points': 'true',
        'lighter_penalties': 'false'
    }
    
    try:
        response = requests.get(url, params=params, timeout=10)
        data = response.json()
        
        return {
            'ip': ip_address,
            'fraud_score': data.get('fraud_score'),
            'is_proxy': data.get('proxy'),
            'is_vpn': data.get('vpn'),
            'is_tor': data.get('tor'),
            'is_bot': data.get('bot_status'),
            'recent_abuse': data.get('recent_abuse'),
            'country': data.get('country_code'),
            'isp': data.get('ISP'),
            'connection_type': data.get('connection_type')
        }
    except Exception as e:
        return {'ip': ip_address, 'error': str(e)}

# Usage
api_key = "YOUR_API_KEY"
result = check_ip_with_ipqs("8.8.8.8", api_key)

if result['fraud_score'] < 25:
    print(f"✅ Clean IP: {result['ip']}")
elif result['fraud_score'] < 75:
    print(f"⚠️ Suspicious IP: {result['ip']}")
else:
    print(f"❌ High-risk IP: {result['ip']}")

Proxy,Status,Speed,Location,Type
192.168.1.1:8080,Working,250ms,USA,Elite
proxy.example.com:3128,Failed,Timeout,-,-
proxy3.com:1080,Working,850ms,Germany,Anonymous

# Ubuntu/Debian
sudo apt-get install proxychains4

# macOS
brew install proxychains-ng

# Test proxy with curl
proxychains4 curl https://ipinfo.io

# Test with custom command
proxychains4 wget https://example.com

import requests
import time
from concurrent.futures import ThreadPoolExecutor, as_completed

def test_single_proxy(proxy, target_url, timeout=10):
    """
    Test single proxy against target URL
    Returns: dict with test results
    """
    proxies = {
        'http': proxy,
        'https': proxy
    }
    
    start_time = time.time()
    
    try:
        response = requests.get(
            target_url,
            proxies=proxies,
            timeout=timeout,
            allow_redirects=True
        )
        
        elapsed = (time.time() - start_time) * 1000  # Convert to ms
        
        return {
            'proxy': proxy,
            'status': 'working',
            'speed_ms': round(elapsed, 2),
            'status_code': response.status_code,
            'response_size': len(response.content)
        }
        
    except requests.exceptions.Timeout:
        return {
            'proxy': proxy,
            'status': 'timeout',
            'error': 'Connection timeout'
        }
    except requests.exceptions.ProxyError:
        return {
            'proxy': proxy,
            'status': 'proxy_error',
            'error': 'Proxy connection failed'
        }
    except Exception as e:
        return {
            'proxy': proxy,
            'status': 'failed',
            'error': str(e)
        }

def test_proxy_list(proxy_list, target_url='https://httpbin.org/ip', max_workers=10):
    """
    Test multiple proxies concurrently
    """
    results = []
    
    with ThreadPoolExecutor(max_workers=max_workers) as executor:
        # Submit all tests
        future_to_proxy = {
            executor.submit(test_single_proxy, proxy, target_url): proxy
            for proxy in proxy_list
        }
        
        # Collect results as they complete
        for future in as_completed(future_to_proxy):
            results.append(future.result())
    
    return results

# Usage Example
if __name__ == '__main__':
    # Your proxy list
    proxies = [
        'http://proxy1.example.com:8080',
        'http://user:[email protected]:8080',
        'socks5://proxy3.example.com:1080'
    ]
    
    # Test against target
    target = 'https://www.google.com'
    results = test_proxy_list(proxies, target_url=target, max_workers=5)
    
    # Display results
    print(f"\nTesting {len(proxies)} proxies against {target}\n")
    print(f"{'Proxy':<40} {'Status':<15} {'Speed':<10}")
    print("-" * 70)
    
    working = 0
    for result in results:
        status = result['status']
        speed = f"{result.get('speed_ms', 0)}ms" if status == 'working' else 'N/A'
        print(f"{result['proxy']:<40} {status:<15} {speed:<10}")
        
        if status == 'working':
            working += 1
    
    print(f"\n✅ Working: {working}/{len(proxies)} ({working/len(proxies)*100:.1f}%)")

python proxy_tester.py

# Test if proxy works
curl --proxy http://proxy.example.com:8080 https://ipinfo.io

# With authentication
curl --proxy http://username:[email protected]:8080 https://ipinfo.io

# SOCKS5 proxy
curl --socks5 proxy.example.com:1080 https://ipinfo.io

# Measure total time
curl --proxy http://proxy.com:8080 \
     -w "Time: %{time_total}s\n" \
     -o /dev/null \
     -s \
     https://www.google.com

# Show all timing metrics
curl --proxy http://proxy.com:8080 \
     -w "\nDNS: %{time_namelookup}s\nConnect: %{time_connect}s\nTTFB: %{time_starttransfer}s\nTotal: %{time_total}s\n" \
     -o /dev/null \
     -s \
     https://example.com

# See all response headers
curl --proxy http://proxy.com:8080 \
     -I \
     https://example.com

#!/bin/bash
# save as: test_proxies.sh

PROXY_LIST="proxies.txt"  # One proxy per line
TARGET_URL="https://ipinfo.io"

echo "Testing proxies from $PROXY_LIST"
echo "=================================="

while IFS= read -r proxy; do
    echo -n "Testing $proxy ... "
    
    response=$(curl --proxy "$proxy" \
                    --connect-timeout 10 \
                    --max-time 15 \
                    -s \
                    "$TARGET_URL")
    
    if [ $? -eq 0 ]; then
        ip=$(echo "$response" | grep -oP '"ip":\s*"\K[^"]+')
        country=$(echo "$response" | grep -oP '"country":\s*"\K[^"]+')
        echo "✅ Working - IP: $ip, Country: $country"
    else
        echo "❌ Failed"
    fi
done < "$PROXY_LIST"

chmod +x test_proxies.sh
./test_proxies.sh

# Basic test
wget -e use_proxy=yes \
     -e http_proxy=proxy.example.com:8080 \
     -O - \
     https://ipinfo.io

# With authentication
wget -e use_proxy=yes \
     -e http_proxy=username:[email protected]:8080 \
     -O - \
     https://ipinfo.io

# Speed test (download file)
wget -e use_proxy=yes \
     -e http_proxy=proxy.example.com:8080 \
     --output-document=/dev/null \
     https://speed.hetzner.de/100MB.bin

#!/usr/bin/env python3
"""
Advanced Proxy Testing Framework
Features: Speed, anonymity, location, target testing
"""

import requests
import time
import json
from concurrent.futures import ThreadPoolExecutor, as_completed
from typing import List, Dict
import statistics

class ProxyTester:
    def __init__(self, timeout=10, max_workers=10):
        self.timeout = timeout
        self.max_workers = max_workers
        self.results = []
    
    def test_availability(self, proxy: str) -> Dict:
        """Test if proxy is responsive"""
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(
                'https://httpbin.org/ip',
                proxies=proxies,
                timeout=self.timeout
            )
            return {
                'available': response.status_code == 200,
                'status_code': response.status_code
            }
        except:
            return {'available': False, 'status_code': None}
    
    def test_speed(self, proxy: str, iterations=3) -> Dict:
        """Test proxy speed with multiple iterations"""
        proxies = {'http': proxy, 'https': proxy}
        times = []
        
        for _ in range(iterations):
            start = time.time()
            try:
                requests.get(
                    'https://www.google.com',
                    proxies=proxies,
                    timeout=self.timeout
                )
                elapsed = (time.time() - start) * 1000
                times.append(elapsed)
            except:
                return {'speed_ms': None, 'speed_rating': 'failed'}
        
        avg_speed = statistics.mean(times)
        
        # Speed rating
        if avg_speed < 500:
            rating = 'excellent'
        elif avg_speed < 1000:
            rating = 'good'
        elif avg_speed < 2000:
            rating = 'acceptable'
        else:
            rating = 'slow'
        
        return {
            'speed_ms': round(avg_speed, 2),
            'speed_min': round(min(times), 2),
            'speed_max': round(max(times), 2),
            'speed_rating': rating
        }
    
    def test_location(self, proxy: str) -> Dict:
        """Get proxy geographic location"""
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(
                'https://ipinfo.io/json',
                proxies=proxies,
                timeout=self.timeout
            )
            data = response.json()
            
            return {
                'ip': data.get('ip'),
                'city': data.get('city'),
                'region': data.get('region'),
                'country': data.get('country'),
                'org': data.get('org')
            }
        except:
            return {
                'ip': None,
                'city': None,
                'region': None,
                'country': None,
                'org': None
            }
    
    def test_anonymity(self, proxy: str) -> Dict:
        """Test proxy anonymity level"""
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            # Check headers that proxy sends
            response = requests.get(
                'https://httpbin.org/headers',
                proxies=proxies,
                timeout=self.timeout
            )
            headers = response.json()['headers']
            
            # Check for revealing headers
            has_xff = 'X-Forwarded-For' in headers
            has_via = 'Via' in headers
            
            if not has_xff and not has_via:
                level = 'elite'
            elif has_via or has_xff:
                level = 'anonymous'
            else:
                level = 'transparent'
            
            return {
                'anonymity_level': level,
                'reveals_proxy': has_via,
                'reveals_ip': has_xff
            }
        except:
            return {
                'anonymity_level': 'unknown',
                'reveals_proxy': None,
                'reveals_ip': None
            }
    
    def test_target_compatibility(self, proxy: str, target_url: str) -> Dict:
        """Test if proxy works with specific target"""
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(
                target_url,
                proxies=proxies,
                timeout=self.timeout
            )
            
            # Check for blocks/CAPTCHAs
            content = response.text.lower()
            blocked = any(keyword in content for keyword in [
                'captcha', 'blocked', 'access denied', 'forbidden'
            ])
            
            return {
                'compatible': response.status_code == 200 and not blocked,
                'status_code': response.status_code,
                'blocked': blocked
            }
        except:
            return {
                'compatible': False,
                'status_code': None,
                'blocked': None
            }
    
    def test_comprehensive(self, proxy: str, target_url=None) -> Dict:
        """Run all tests on a proxy"""
        print(f"Testing {proxy}...")
        
        result = {'proxy': proxy}
        
        # Test 1: Availability
        avail = self.test_availability(proxy)
        result.update(avail)
        
        if not avail['available']:
            result['overall_status'] = 'failed'
            return result
        
        # Test 2: Speed
        speed = self.test_speed(proxy)
        result.update(speed)
        
        # Test 3: Location
        location = self.test_location(proxy)
        result.update(location)
        
        # Test 4: Anonymity
        anonymity = self.test_anonymity(proxy)
        result.update(anonymity)
        
        # Test 5: Target compatibility (optional)
        if target_url:
            compat = self.test_target_compatibility(proxy, target_url)
            result.update(compat)
        
        # Overall rating
        if speed['speed_ms'] and speed['speed_ms'] < 1000:
            result['overall_status'] = 'excellent'
        elif speed['speed_ms'] and speed['speed_ms'] < 2000:
            result['overall_status'] = 'good'
        else:
            result['overall_status'] = 'acceptable'
        
        return result
    
    def test_batch(self, proxy_list: List[str], target_url=None) -> List[Dict]:
        """Test multiple proxies concurrently"""
        results = []
        
        with ThreadPoolExecutor(max_workers=self.max_workers) as executor:
            futures = {
                executor.submit(self.test_comprehensive, proxy, target_url): proxy
                for proxy in proxy_list
            }
            
            for future in as_completed(futures):
                results.append(future.result())
        
        self.results = results
        return results
    
    def export_results(self, filename='proxy_test_results.json'):
        """Export test results to JSON"""
        with open(filename, 'w') as f:
            json.dump(self.results, f, indent=2)
        print(f"✅ Results exported to {filename}")
    
    def print_summary(self):
        """Print human-readable summary"""
        if not self.results:
            print("No results to display")
            return
        
        print("\n" + "="*80)
        print("PROXY TESTING RESULTS")
        print("="*80)
        
        working = [r for r in self.results if r.get('available')]
        print(f"\n✅ Working: {len(working)}/{len(self.results)}")
        
        if working:
            speeds = [r['speed_ms'] for r in working if r.get('speed_ms')]
            if speeds:
                print(f"⚡ Avg Speed: {statistics.mean(speeds):.2f}ms")
                print(f"⚡ Fastest: {min(speeds):.2f}ms")
                print(f"⚡ Slowest: {max(speeds):.2f}ms")
        
        print("\n" + "-"*80)
        print(f"{'Proxy':<40} {'Status':<10} {'Speed':<10} {'Location':<15} {'Anonymity':<10}")
        print("-"*80)
        
        for r in self.results:
            proxy = r['proxy'][:38]
            status = '✅' if r.get('available') else '❌'
            speed = f"{r.get('speed_ms', 0):.0f}ms" if r.get('speed_ms') else 'N/A'
            location = f"{r.get('country', 'N/A')}"
            anon = r.get('anonymity_level', 'N/A')
            
            print(f"{proxy:<40} {status:<10} {speed:<10} {location:<15} {anon:<10}")

# Usage Example
if __name__ == '__main__':
    # Your proxy list
    proxies = [
        'http://proxy1.example.com:8080',
        'http://user:[email protected]:8080',
        'http://proxy3.example.com:8080'
    ]
    
    # Initialize tester
    tester = ProxyTester(timeout=15, max_workers=5)
    
    # Test all proxies
    print("Starting comprehensive proxy testing...\n")
    results = tester.test_batch(proxies, target_url='https://www.google.com')
    
    # Display results
    tester.print_summary()
    
    # Export to JSON
    tester.export_results('proxy_results.json')

python advanced_proxy_tester.py

# ❌ Wrong format
proxy = 'http://proxy.com:8080'  # Missing credentials

# ✅ Correct format
proxy = 'http://username:[email protected]:8080'

# Check your current IP
curl https://ipinfo.io/ip

# Add to provider's whitelist

# Try different protocols
proxies = [
    'http://proxy.com:8080',   # HTTP
    'https://proxy.com:8080',  # HTTPS
    'socks5://proxy.com:1080'  # SOCKS5
]

# Test proxy speed with fast endpoint
curl --proxy http://proxy.com:8080 \
     -w "Time: %{time_total}s\n" \
     -o /dev/null \
     -s \
     https://www.google.com

# Use proxy's DNS
proxies = {
    'http': 'http://proxy.com:8080',
    'https': 'http://proxy.com:8080'
}

# Don't use system DNS

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
    'Accept-Language': 'en-US,en;q=0.5',
    'Accept-Encoding': 'gzip, deflate',
    'DNT': '1',
    'Connection': 'keep-alive',
    'Upgrade-Insecure-Requests': '1'
}

import time
time.sleep(random.uniform(2, 5))

session = requests.Session()
session.proxies = proxies
session.headers = headers

# Maintain cookies and session
response1 = session.get(url1)
response2 = session.get(url2)  # Uses same session

# Don't just test Google
target = 'https://your-actual-target.com'
test_proxy(proxy, target)

# One test isn't enough
for i in range(5):
    result = test_proxy(proxy, target)
    # Check consistency

# Log all test results
results = {
    'date': '2025-11-04',
    'proxy': proxy,
    'tests': [test1, test2, test3],
    'avg_speed': avg_speed,
    'success_rate': success_rate
}

# ❌ Wrong
test_proxy_with_google(proxy)  # Google works
use_for_instagram(proxy)  # Instagram blocks

# ✅ Correct
test_proxy_with_instagram(proxy)  # Test actual target

# ❌ Don't hammer servers
for proxy in 1000_proxies:
    test_immediately(proxy)

# ✅ Add delays
for proxy in 1000_proxies:
    test(proxy)
    time.sleep(1)  # Be respectful

# Schedule with cron
0 */6 * * * python /path/to/proxy_tester.py  # Every 6 hours

# Try common formats
formats = [
    f'http://{ip}:{port}',
    f'http://user:pass@{ip}:{port}',
    f'socks5://{ip}:{port}'
]

for format in formats:
    if test_proxy(format):
        print(f"Working format: {format}")