Бесплатно пользуемся публичными прокси [скрипт для парсинга]

Noiloo · 13 Май 2025

Здарова! Нашел скрипт, который позволит автоматизировать сбор бесплатных прокси с различных сайтов. Маст хэв для всех нищеебов.

Короче, если ввести в гугле «бесплатные прокси», то мы получим целую кучу сайтов с халявными проксями. Так вот, с именно с таких ресурсов мы и будем их парсить.

Устанавливаем Python версии 3.13+, накатываем библиотеку

Код:

Beautiful Soup pip install requests beautifulsoup4

и юзаем код:

Код:

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):

  """Парсер для сайта [URL='https://hidxxy.name/proxy-list/']https://hidxxy.name/proxy-list/"""[/URL]

  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]

Для проверки работоспобности используем этот скрипт:

Код:

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]

Для тех кто не понял первый скрипт - парсер прокси. второй скрипт - проверка прокси на валид.

В-С-Ё!

FOBAS · 13 Май 2025

а как установить и запустить можно поподробней?

Noiloo · 13 Май 2025

FOBAS написал(а):
а как установить и запустить можно поподробней?

Код из первого спойлера вставь в файл parser.py (название можешь придумать свое)
Дальше выполни:

Код:

python parser.py

Получишь proxies.txt со списком прокси

С чекером тоже самое)

veryfry · 13 Май 2025

ебать ты лега

Noiloo · 14 Май 2025

veryfry написал(а):
ебать ты лега

Не понял, но сочту за комлимент)

Мелисса · 16 Май 2025

Noiloo написал(а):
Не понял, но сочту за комлимент)

легенда

Привет, гость!

Бесплатно пользуемся публичными прокси [скрипт для парсинга]

Noiloo

FOBAS

Noiloo

veryfry

Noiloo

Мелисса

Похожие темы