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

Важная информация

​

​

Приветствую, уважаемые читатели!​

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

1. Поиск ****** вручную​

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

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

Примеры сайтов

2. Автоматизация сбора ******​

Для автоматизации процесса вам понадобится:

• Python (версии 3.13+)
• Установленные библиотеки:
  pip install requests beautifulsoup4

  Код

  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):
"""Парсер для сайта [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]

Python

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]

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]

Python

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]

Заключение​

Таким образом, вы можете:

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

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

Удачи в использовании!​