Получаем бесплатные паблик прокси

[bratva]

В этой статье я расскажу, как автоматизировать сбор бесплатных прокси с различных сайтов с помощью Python-скрипта. Также поделюсь инструментом для проверки работоспособности найденных прокси.

1. Поиск прокси вручную�

Самый простой способ найти прокси - это поиск в Google:

Вводим запрос "Бесплатные прокси"
Переходим на любой из сайтов в результатах поиска

2. Автоматизация сбора прокси�

Для автоматизации процесса вам понадобится:
Python (версии 3.13+)
Установленные библиотеки:

"pip install requests beautifulsoup4"

3. Скрипт для парсинга прокси

"import requests
from bs4 import BeautifulSoup
import re
import time
import base64
from concurrent.futures import ThreadPoolExecutor, as_completed

# Настройки
USER_AGENT = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
TIMEOUT = 10
OUTPUT_FILE = "proxies.txt"
PROXY_PATTERN = re.compile(r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}:[0-9]{1,5}\b')
MAX_PAGES = 50  # Максимальное количество страниц для проверки
MAX_WORKERS = 5  # Количество потоков для параллельного парсинга

# Список сайтов для парсинга
SITES = [
    {"url": "https://proxylib.com/free-proxy-list/?proxy_page={page}", "paginated": True},
    {"url": "https://github.com/proxifly/free-proxy-list/blob/main/proxies/all/data.txt", "paginated": False},
    {"url": "https://geonode.com/free-proxy-list?", "paginated": False},
    {"url": "http://free-proxy.cz/ru/proxylist/main/{page}", "paginated": True, "special_parser": "free-proxy-cz"},
    {"url": "https://hidxxy.name/proxy-list/?start={start}", "paginated": True, "params": {"start": 0}, "special_parser": "hidxxy"},
    # Добавляйте другие сайты здесь
]

def get_page_content(url):
    headers = {"User-Agent": USER_AGENT}
    try:
        response = requests.get(url, headers=headers, timeout=TIMEOUT)
        response.raise_for_status()
        return response.text
    except Exception as e:
        print(f" Ошибка при загрузке {url}: {e}")
        return None

def parse_free_proxy_cz(content):
    """Специальный парсер для free-proxy.cz"""
    soup = BeautifulSoup(content, 'html.parser')
    proxies = set()
 
    table = soup.find('table', {'id': 'proxy_list'})
    if not table:
        return proxies
 
    for row in table.find_all('tr')[1:]:  # Пропускаем заголовок
        cols = row.find_all('td')
        if len(cols) >= 2:
            # Парсим IP (может быть в base64)
            ip_element = cols[0].find('script')
            if ip_element:
                ip_encoded = re.search(r'Base64.decode\("([^"]+)"\)', ip_element.text)
                if ip_encoded:
                    try:
                        ip = base64.b64decode(ip_encoded.group(1)).decode('utf-8')
                    except:
                        ip = cols[0].get_text(strip=True)
                else:
                    ip = cols[0].get_text(strip=True)
            else:
                ip = cols[0].get_text(strip=True)
 
            # Парсим порт
            port_element = cols[1].find('span', class_='fport')
            port = port_element.get_text(strip=True) if port_element else cols[1].get_text(strip=True)
 
            if re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', ip) and port.isdigit():
                proxies.add(f"{ip}:{port}")
 
    return proxies

def parse_hidxxy(content):
    """Парсер для сайта https://hidxxy.name/proxy-list/"""
    soup = BeautifulSoup(content, 'html.parser')
    proxies = set()
    rows = soup.find_all('tr')
    for row in rows:
        tds = row.find_all('td')
        if len(tds) >= 2:
            ip = tds[0].get_text(strip=True)
            port = tds[1].get_text(strip=True)
            if re.match(r'^\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}$', ip) and port.isdigit():
                proxies.add(f"{ip}:{port}")
    return proxies
def detect_and_parse(content, special_parser=None):
    """Автоматически определяет способ парсинга"""
    if special_parser == "free-proxy-cz":
        return parse_free_proxy_cz(content)
    elif special_parser == "hidxxy":
        return parse_hidxxy(content)
 
    soup = BeautifulSoup(content, 'html.parser')
 
    # 1. GitHub-подобные textarea
    textarea = soup.find('textarea', {'id': 'read-only-cursor-text-area'})
    if textarea:
        return set(PROXY_PATTERN.findall(textarea.text))
 
    # 2. Кнопки с copyToClipboard
    copy_buttons = soup.find_all(onclick=re.compile(r'copyToClipboard\([\'"](.*?)[\'"]\)'))
    if copy_buttons:
        proxies = set()
        for btn in copy_buttons:
            match = re.search(r'copyToClipboard\([\'"](.*?)[\'"]\)', btn['onclick'])
            if match and ':' in match.group(1):
                proxies.add(match.group(1))
        return proxies
 
    # 3. Таблицы с IP и портами
    tables = soup.find_all('table')
    for table in tables:
        proxies = set()
        for row in table.find_all('tr'):
            cells = [c.get_text(strip=True) for c in row.find_all('td')]
            if len(cells) >= 2:
                ip_match = re.search(r'\b(?:[0-9]{1,3}\.){3}[0-9]{1,3}\b', cells[0])
                port_match = re.search(r'\b[0-9]{1,5}\b', cells[1])
                if ip_match and port_match:
                    proxies.add(f"{ip_match.group(0)}:{port_match.group(0)}")
        if proxies:
            return proxies
 
    # 4. Универсальный поиск
    return set(PROXY_PATTERN.findall(content))

def scrape_page(url, special_parser=None):
    """Парсит одну страницу"""
    content = get_page_content(url)
    if not content:
        return set()
    return detect_and_parse(content, special_parser)

def scrape_paginated_site(base_url, special_parser=None, params=None):
    """Парсит сайт с пагинацией с использованием многопоточности"""
    all_proxies = set()
 
    def process_page(page_number, param_values):
        if param_values:
            # Формируем URL с параметрами
            url = base_url.format(**param_values)
        else:
            # Формируем URL с номером страницы
            url = base_url.format(page=page_number)
 
        proxies = scrape_page(url, special_parser)
        if proxies:
            print(f" Страница {page_number}: найдено {len(proxies)} прокси")
        return proxies
 
    with ThreadPoolExecutor(max_workers=MAX_WORKERS) as executor:
        futures = []
 
        # Для сайтов с параметрами (например, hidxxy)
        if params is not None:
            for page in range(1, MAX_PAGES + 1):
                # Обновляем параметры для каждой страницы
                param_values = {}
                for key, val in params.items():
                    if key == 'start':
                        param_values[key] = val + (page - 1) * 64
                    else:
                        param_values[key] = val
     
                futures.append(executor.submit(process_page, page, param_values))
                time.sleep(0.1)  # Небольшая задержка между запросами
        else:
            # Для обычных пагинированных сайтов
            for page in range(1, MAX_PAGES + 1):
                futures.append(executor.submit(process_page, page, None))
                time.sleep(0.1)  # Небольшая задержка между запросами
 
        for future in as_completed(futures):
            try:
                proxies = future.result()
                if proxies:  # Добавляем только если есть прокси
                    all_proxies.update(proxies)
            except Exception as e:
                print(f" Ошибка при парсинге страницы: {e}")
                continue
 
    return all_proxies

def scrape_single_site(url, special_parser=None):
    """Парсит обычный сайт без пагинации"""
    print(f"\n Анализируем {url}...")
    return scrape_page(url, special_parser)
def save_proxies(proxies, filename):
    """Сохраняет прокси в файл"""
    with open(filename, 'a') as f:
        f.write('\n'.join(proxies) + '\n')
    print(f" Сохранено {len(proxies)} прокси в {filename}")

def main():
    print(" Начинаем парсинг прокси...")
    open(OUTPUT_FILE, 'w').close()  # Очищаем файл
 
    total_proxies = set()
 
    for site in SITES:
        start_time = time.time()
        site_proxies = set()
 
        try:
            if site.get("paginated", False):
                print(f"\n Анализируем пагинированный сайт: {site['url']}")
                proxies = scrape_paginated_site(
                    site["url"],
                    special_parser=site.get("special_parser"),
                    params=site.get("params")
                )
            else:
                proxies = scrape_single_site(
                    site["url"],
                    special_parser=site.get("special_parser")
                )
 
            site_proxies.update(proxies)
            total_proxies.update(proxies)
 
            if proxies:
                save_proxies(proxies, OUTPUT_FILE)
 
            print(f" Время обработки: {time.time() - start_time:.2f} сек")
            print(f" Найдено на этом сайте: {len(proxies)} прокси")
        except Exception as e:
            print(f" Критическая ошибка при обработке сайта {site['url']}: {e}")
            continue
 
    print(f"\n Всего найдено прокси: {len(total_proxies)}")
    print(f" Результаты сохранены в {OUTPUT_FILE}")

if name == "main":
    main()[/CENTER]"

4. Проверка работоспособности прокси�

Для проверки найденных прокси используйте этот скрипт:

"import requests
from concurrent.futures import ThreadPoolExecutor
from threading import Lock
import time

# Настройки
TEST_URL = "http://httpbin.org/ip"  # заменить на нужный сайт
TIMEOUT = 5  # Таймаут в секундах
MAX_THREADS = 100  # Количество потоков (регулируйте в зависимости от мощности ПК)
INPUT_FILE = "proxies.txt"  # Файл с прокси (формат: ip:port)
OUTPUT_FILE = "working_proxies.txt"  # Файл для рабочих прокси

# Блокировка для безопасной записи в файл
lock = Lock()

def check_proxy(proxy):
    proxy_types = ["http", "https", "socks4", "socks5"]
 
    for proxy_type in proxy_types:
        proxies = {
            "http": f"{proxy_type}://{proxy}",
            "https": f"{proxy_type}://{proxy}"
        }
 
        try:
            start_time = time.time()
            response = requests.get(
                TEST_URL,
                proxies=proxies,
                timeout=TIMEOUT
            )
            response_time = round((time.time() - start_time) * 1000)  # В миллисекундах
 
            if response.status_code == 200:
                print(f"

• Рабочий: {proxy} | Тип: {proxy_type} | Время: {response_time}ms")

                with lock:
                    with open(OUTPUT_FILE, "a") as f:
                        f.write(f"{proxy}|{proxy_type}|{response_time}ms\n")
                return True
        except:
            continue
 
    print(f"[-] Не рабочий: {proxy}")
    return False

def main():
    print("Загрузка списка прокси...")
    with open(INPUT_FILE, "r") as f:
        proxies = [line.strip() for line in f if line.strip()]
 
    print(f"Найдено прокси: {len(proxies)}")
    print("Начинаю проверку...")
 
    # Очистка файла перед записью
    with open(OUTPUT_FILE, "w") as f:
        f.write("")
 
    # Многопоточная проверка
    with ThreadPoolExecutor(max_workers=MAX_THREADS) as executor:
        executor.map(check_proxy, proxies)
 
    print("\nПроверка завершена!")
    with open(OUTPUT_FILE, "r") as f:
        working_count = len(f.readlines())
    print(f"Рабочих прокси: {working_count} (сохранено в {OUTPUT_FILE})")

if name == "main":
    main()[/CENTER]"

Заключение�

Таким образом, вы можете:
Получать бесплатные паблик прокси
Автоматически собирать прокси с различных сайтов
Проверять их работоспособность
Настраивать скрипт под свои нужды

Скрипты можно дорабатывать - добавлять новые сайты, улучшать алгоритмы проверки.