Điều cần làm nếu proxy bị cấm liên tục: hướng dẫn hoàn chỉnh về chẩn đoán và giải quyết vấn đề

Các lần chặn proxy liên tục là một trong những vấn đề phổ biến nhất khi phân tích cú pháp, tự động hóa và làm việc với nhiều tài khoản. Trong bài viết này, chúng tôi sẽ phân tích lý do tại sao điều này xảy ra và cách giải quyết vấn đề một cách có hệ thống, thay vì liên tục thay đổi nhà cung cấp với hy vọng có phép lạ.

Tại sao proxy thực sự bị cấm

Trước khi tìm kiếm giải pháp, bạn cần hiểu cơ chế chặn. Các hệ thống chống gian lận hiện đại sử dụng bảo vệ đa cấp, và cấm proxy chỉ là hệ quả, không phải nguyên nhân. Hiểu cách hoạt động của các hệ thống này cho phép bạn xây dựng một chiến lược vượt qua hiệu quả.

Danh tiếng IP và danh sách đen

Mỗi địa chỉ IP có danh tiếng được hình thành dựa trên lịch sử sử dụng của nó. Nếu một địa chỉ trước đây được sử dụng cho spam, tấn công DDoS hoặc phân tích cú pháp hàng loạt, nó sẽ được đưa vào các cơ sở dữ liệu như Spamhaus, SORBS hoặc danh sách riêng của các dịch vụ cụ thể. Khi bạn kết nối thông qua một IP như vậy, hệ thống ngay lập tức coi bạn với sự nghi ngờ.

Proxy trung tâm dữ liệu đặc biệt dễ bị vấn đề này. Toàn bộ các mạng con có thể được đánh dấu là "lưu trữ", và bất kỳ lưu lượng nào từ chúng sẽ tự động nhận mức độ kiểm tra cao hơn. Amazon AWS, Google Cloud, DigitalOcean — các dải IP của họ được biết rõ và thường bị chặn một cách phòng ngừa.

Bạn có thể kiểm tra danh tiếng IP thông qua các dịch vụ như IPQualityScore, Scamalytics hoặc AbuseIPDB. Nếu proxy của bạn hiển thị fraud score cao hơn 75, vấn đề chính xác là ở đây — hãy thay đổi nhà cung cấp hoặc loại proxy.

Mẫu yêu cầu

Một người không thực hiện 100 yêu cầu mỗi giây. Một người không chuyển qua các trang với độ tuần hoàn hoàn hảo là 2 giây. Một người không bỏ qua hình ảnh, CSS và JavaScript, chỉ yêu cầu HTML. Các hệ thống chống gian lận phân tích chính xác những mẫu này, và bất kỳ sai lệch nào từ hành vi "con người" sẽ tăng nguy cơ chặn.

Đặc biệt thể hiện là thống kê về thời gian giữa các yêu cầu. Nếu bạn có khoảng thời gian ổn định — đây là dấu hiệu rõ ràng của tự động hóa. Thêm độ trễ ngẫu nhiên (ví dụ: từ 1 đến 5 giây) sẽ giảm đáng kể khả năng phát hiện.

Không phù hợp siêu dữ liệu

Khi User-Agent của bạn nói rằng bạn đang sử dụng Chrome trên Windows, nhưng các tiêu đề HTTP tiết lộ đặc điểm của Python requests — đây là cờ đỏ. Khi địa chỉ IP được địa phương hóa ở Đức, nhưng cài đặt ngôn ngữ trình duyệt chỉ ra tiếng Nga — một cờ đỏ khác. Khi múi giờ trong JavaScript không khớp với địa lý IP — cờ thứ ba.

Sự tích lũy của những không phù hợp này dẫn đến việc hệ thống phân loại kết nối là đáng nghi ngờ và áp dụng các biện pháp bảo vệ: từ captcha đến chặn IP hoàn toàn.

Dấu vân tay trình duyệt

Các hệ thống bảo vệ hiện đại thu thập hàng chục tham số trình duyệt: độ phân giải màn hình, phông chữ được cài đặt, plugin, kết xuất WebGL, bối cảnh âm thanh và nhiều thứ khác. Tổng hợp các tham số này tạo ra một "dấu vân tay" duy nhất, vẫn giữ nguyên ngay cả khi thay đổi IP.

Nếu bạn thay đổi proxy nhưng dấu vân tay vẫn giữ nguyên, hệ thống hiểu rằng đây là cùng một người dùng. Và nếu một dấu vân tay xuất hiện từ hàng trăm IP khác nhau trong thời gian ngắn — đây là dấu hiệu rõ ràng của tự động hóa.

Chẩn đoán: cách hiểu nguyên nhân chặn

Trước khi thay đổi cài đặt một cách mù quáng, hãy tiến hành chẩn đoán. Điều này sẽ tiết kiệm hàng giờ thử nghiệm và giúp bạn tìm ra nguyên nhân thực sự của vấn đề. Cách tiếp cận có hệ thống để chẩn đoán là chìa khóa để giải quyết hiệu quả.

Bước 1: Kiểm tra proxy

Bắt đầu với kiểm tra cơ bản về chức năng proxy độc lập với tập lệnh chính của bạn:

import requests

proxy = {
    "http": "http://user:pass@proxy-server:port",
    "https": "http://user:pass@proxy-server:port"
}

# Kiểm tra chức năng cơ bản
try:
    response = requests.get("https://httpbin.org/ip", proxies=proxy, timeout=10)
    print(f"IP qua proxy: {response.json()['origin']}")
except Exception as e:
    print(f"Lỗi kết nối: {e}")

# Kiểm tra rò rỉ IP thực
response = requests.get("https://browserleaks.com/ip", proxies=proxy)
# So sánh với IP thực của bạn

Nếu proxy không hoạt động ngay cả trên các yêu cầu đơn giản — vấn đề nằm ở chính proxy hoặc thông tin xác thực. Kiểm tra tính chính xác của định dạng kết nối, sự có sẵn của tiền trên số dư và giới hạn của nhà cung cấp.

Bước 2: Kiểm tra danh tiếng IP

Sử dụng nhiều dịch vụ để đánh giá toàn diện:

# Lấy IP proxy
proxy_ip = requests.get("https://api.ipify.org", proxies=proxy).text

# Kiểm tra trên các dịch vụ này:
# https://www.ipqualityscore.com/free-ip-lookup-proxy-vpn-test
# https://scamalytics.com/ip/{proxy_ip}
# https://www.abuseipdb.com/check/{proxy_ip}
# https://whatismyipaddress.com/ip/{proxy_ip}

print(f"Kiểm tra IP {proxy_ip} trên các dịch vụ trên")

Chú ý đến các chỉ số sau: fraud score (phải thấp hơn 50), loại IP (residential tốt hơn datacenter), sự có mặt trong danh sách đen. Nếu IP được đánh dấu là VPN/Proxy — nhiều trang web sẽ coi nó với sự nghi ngờ từ đầu.

Bước 3: Cô lập vấn đề

Hãy thử cùng một proxy trên các trang web đích khác nhau. Nếu chặn xảy ra ở mọi nơi — vấn đề nằm ở proxy hoặc cài đặt của bạn. Nếu chỉ trên một trang web cụ thể — vấn đề nằm ở bảo vệ của trang web đó hoặc hành vi của bạn trên đó.

Cũng hãy thử các proxy khác nhau trên một trang web. Nếu tất cả đều bị chặn — vấn đề không phải ở proxy, mà ở tập lệnh, dấu vân tay hoặc mẫu hành vi của bạn. Đây là một bài kiểm tra cực kỳ quan trọng mà nhiều người bỏ qua.

Bước 4: Phân tích phản hồi máy chủ

Các loại chặn khác nhau biểu hiện khác nhau. Học cách phân biệt chúng:

def analyze_response(response):
    status = response.status_code
    
    if status == 403:
        print("Truy cập bị từ chối — có thể IP trong danh sách đen")
    elif status == 429:
        print("Quá nhiều yêu cầu — giảm tần suất")
    elif status == 503:
        print("Dịch vụ không khả dụng — có thể bảo vệ DDoS")
    elif status == 407:
        print("Yêu cầu xác thực proxy — kiểm tra thông tin xác thực")
    elif "captcha" in response.text.lower():
        print("Phát hiện captcha — nghi ngờ bot")
    elif "blocked" in response.text.lower():
        print("Chặn rõ ràng — thay đổi IP và xem xét lại cách tiếp cận")
    elif len(response.text) < 1000:
        print("Phản hồi ngắn đáng ngờ — có thể là stub")
    else:
        print(f"Trạng thái {status}, độ dài phản hồi: {len(response.text)}")

Xoay vòng đúng cách: tần suất, logic, triển khai

Xoay vòng proxy không chỉ là "thay đổi IP thường xuyên hơn". Xoay vòng không đúng cách có thể gây hại nhiều hơn so với không xoay vòng. Hãy xem xét các chiến lược khác nhau và khi nào áp dụng chúng.

Chiến lược 1: Xoay vòng theo số lượng yêu cầu

Cách tiếp cận đơn giản nhất — thay đổi IP sau một số yêu cầu nhất định. Phù hợp để phân tích cú pháp, nơi không cần tính phiên:

import random

class ProxyRotator:
    def __init__(self, proxy_list, requests_per_proxy=50):
        self.proxies = proxy_list
        self.requests_per_proxy = requests_per_proxy
        self.current_proxy = None
        self.request_count = 0
    
    def get_proxy(self):
        if self.current_proxy is None or self.request_count >= self.requests_per_proxy:
            # Thêm tính ngẫu nhiên vào số lượng yêu cầu
            self.requests_per_proxy = random.randint(30, 70)
            self.current_proxy = random.choice(self.proxies)
            self.request_count = 0
        
        self.request_count += 1
        return self.current_proxy

# Sử dụng
rotator = ProxyRotator(proxy_list)
for url in urls_to_scrape:
    proxy = rotator.get_proxy()
    response = requests.get(url, proxies={"http": proxy, "https": proxy})

Lưu ý tính ngẫu nhiên trong số lượng yêu cầu trên proxy. Một số cố định (ví dụ: chính xác 50) là một mẫu có thể được phát hiện. Một dải ngẫu nhiên làm cho hành vi ít dự đoán hơn.

Chiến lược 2: Xoay vòng theo thời gian

Đối với các nhiệm vụ mà tính phiên là quan trọng (ví dụ: làm việc với tài khoản), tốt hơn là liên kết IP với thời gian:

import time
import random

class TimeBasedRotator:
    def __init__(self, proxy_list, min_minutes=10, max_minutes=30):
        self.proxies = proxy_list
        self.min_seconds = min_minutes * 60
        self.max_seconds = max_minutes * 60
        self.current_proxy = None
        self.rotation_time = 0
    
    def get_proxy(self):
        current_time = time.time()
        
        if self.current_proxy is None or current_time >= self.rotation_time:
            self.current_proxy = random.choice(self.proxies)
            # Khoảng thời gian ngẫu nhiên cho đến lần xoay vòng tiếp theo
            interval = random.randint(self.min_seconds, self.max_seconds)
            self.rotation_time = current_time + interval
            print(f"Proxy mới, xoay vòng tiếp theo trong {interval//60} phút")
        
        return self.current_proxy

Chiến lược 3: Phiên dính cho tài khoản

Khi làm việc với nhiều tài khoản, điều quan trọng là mỗi tài khoản sử dụng một IP không đổi. Thay đổi IP cho một tài khoản đã đăng nhập — đây là cách chắc chắn để bị cấm:

class AccountProxyManager:
    def __init__(self, proxy_pool):
        self.proxy_pool = proxy_pool
        self.account_proxies = {}  # account_id -> proxy
        self.used_proxies = set()
    
    def get_proxy_for_account(self, account_id):
        # Nếu tài khoản đã được gán proxy — trả về nó
        if account_id in self.account_proxies:
            return self.account_proxies[account_id]
        
        # Tìm proxy miễn phí
        available = [p for p in self.proxy_pool if p not in self.used_proxies]
        
        if not available:
            raise Exception("Không có proxy miễn phí cho tài khoản mới")
        
        proxy = random.choice(available)
        self.account_proxies[account_id] = proxy
        self.used_proxies.add(proxy)
        
        return proxy
    
    def release_account(self, account_id):
        """Giải phóng proxy khi xóa tài khoản"""
        if account_id in self.account_proxies:
            proxy = self.account_proxies.pop(account_id)
            self.used_proxies.discard(proxy)

# Sử dụng
manager = AccountProxyManager(residential_proxy_list)

for account in accounts:
    proxy = manager.get_proxy_for_account(account.id)
    # Tất cả các hành động của tài khoản này đi qua một IP

Chiến lược 4: Xoay vòng thích ứng

Cách tiếp cận nâng cao nhất — thay đổi proxy để phản hồi các tín hiệu từ trang web đích:

class AdaptiveRotator:
    def __init__(self, proxy_list):
        self.proxies = proxy_list
        self.current_proxy = random.choice(proxy_list)
        self.proxy_scores = {p: 100 for p in proxy_list}  # "Sức khỏe" ban đầu của proxy
    
    def get_proxy(self):
        return self.current_proxy
    
    def report_result(self, success, response_code=200):
        """Được gọi sau mỗi yêu cầu"""
        if success and response_code == 200:
            # Yêu cầu thành công — tăng score một chút
            self.proxy_scores[self.current_proxy] = min(100, 
                self.proxy_scores[self.current_proxy] + 1)
        elif response_code == 429:
            # Giới hạn tỷ lệ — giảm mạnh và xoay vòng
            self.proxy_scores[self.current_proxy] -= 30
            self._rotate()
        elif response_code == 403:
            # Cấm — đặt lại score và xoay vòng
            self.proxy_scores[self.current_proxy] = 0
            self._rotate()
        elif response_code == 503:
            # Bảo vệ có thể — giảm và xoay vòng
            self.proxy_scores[self.current_proxy] -= 20
            self._rotate()
    
    def _rotate(self):
        # Chọn proxy có score tốt nhất
        available = [(p, s) for p, s in self.proxy_scores.items() if s > 20]
        if not available:
            # Tất cả proxy đều "chết" — đặt lại scores
            self.proxy_scores = {p: 50 for p in self.proxies}
            available = list(self.proxy_scores.items())
        
        # Lựa chọn có trọng số theo score
        self.current_proxy = max(available, key=lambda x: x[1])[0]
        print(f"Xoay vòng đến proxy với score {self.proxy_scores[self.current_proxy]}")

Dấu vân tay trình duyệt và vai trò của nó trong các lần chặn

Fingerprint là tổng hợp các đặc điểm của trình duyệt cho phép xác định người dùng ngay cả không có cookies. Nếu bạn thay đổi IP nhưng dấu vân tay vẫn giữ nguyên, hệ thống bảo vệ dễ dàng liên kết tất cả các phiên của bạn lại với nhau.

Dấu vân tay bao gồm những gì

Dấu vân tay hiện đại bao gồm hàng chục tham số. Dưới đây là các danh mục chính:

Sự phù hợp của dấu vân tay và IP

Điều quan trọng là dấu vân tay phù hợp với địa lý IP. Nếu proxy ở Đức, dấu vân tay phải trông giống như người dùng Đức:

// Ví dụ về không phù hợp (TỐI):
// IP: Đức
// Múi giờ: America/New_York
// Ngôn ngữ: ["ru-RU", "ru"]
// Điều này sẽ gây ra nghi ngờ

// Dấu vân tay phù hợp (TỐT):
// IP: Đức
// Múi giờ: Europe/Berlin
// Ngôn ngữ: ["de-DE", "de", "en-US", "en"]

Công cụ quản lý dấu vân tay

Để làm việc nghiêm túc, hãy sử dụng các công cụ chuyên dụng:

Playwright với Stealth:

from playwright.sync_api import sync_playwright
from playwright_stealth import stealth_sync

with sync_playwright() as p:
    browser = p.chromium.launch(
        proxy={"server": "http://proxy:port", "username": "user", "password": "pass"}
    )
    
    context = browser.new_context(
        viewport={"width": 1920, "height": 1080},
        locale="de-DE",
        timezone_id="Europe/Berlin",
        geolocation={"latitude": 52.52, "longitude": 13.405},
        permissions=["geolocation"]
    )
    
    page = context.new_page()
    stealth_sync(page)  # Áp dụng các bản vá stealth
    
    page.goto("https://target-site.com")

Puppeteer với puppeteer-extra:

const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    args: [`--proxy-server=http://proxy:port`]
});

const page = await browser.newPage();

// Ghi đè múi giờ
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', {
        value: function() {
            return { timeZone: 'Europe/Berlin' };
        }
    });
});

Trình duyệt chống phát hiện

Để làm việc với tài khoản, thường sử dụng trình duyệt chống phát hiện (Multilogin, GoLogin, Dolphin Anty và những trình khác). Chúng cho phép tạo các hồ sơ cô lập với dấu vân tay duy nhất. Mỗi hồ sơ có bộ tham số riêng, cookies, localStorage — môi trường hoàn toàn cô lập.

Ưu điểm của trình duyệt chống phát hiện — chúng giải quyết vấn đề dấu vân tay "ngay từ hộp". Nhược điểm — chi phí và độ phức tạp của tự động hóa (mặc dù nhiều trình có API).

Mẫu hành vi: cách không trông giống như bot

Ngay cả với dấu vân tay hoàn hảo và IP sạch, bạn có thể bị cấm do hành vi không giống con người. Các hệ thống hiện đại phân tích không chỉ các tham số kỹ thuật mà còn các mẫu tương tác với trang web.

Độ trễ thời gian

Con người không thực hiện các yêu cầu với khoảng thời gian không đổi. Thêm độ trễ ngẫu nhiên với phân phối bình thường:

import random
import time
import numpy as np

def human_delay(min_sec=1, max_sec=5, mean=2.5):
    """
    Tạo độ trễ giống con người.
    Sử dụng phân phối lognormal — 
    hầu hết các độ trễ ngắn, nhưng đôi khi lại dài.
    """
    delay = np.random.lognormal(mean=np.log(mean), sigma=0.5)
    delay = max(min_sec, min(max_sec, delay))
    return delay

def human_typing_delay():
    """Độ trễ giữa các lần nhấn phím khi nhập văn bản"""
    return random.uniform(0.05, 0.25)

# Sử dụng
for url in urls:
    response = requests.get(url, proxies=proxy)
    process(response)
    time.sleep(human_delay())  # Tạm dừng ngẫu nhiên giữa các yêu cầu

Mô phỏng điều hướng

Con người không chuyển trực tiếp đến trang sản phẩm qua liên kết trực tiếp. Anh ta vào trang chủ, sử dụng tìm kiếm, duyệt các danh mục. Mô phỏng con đường này:

async def human_like_navigation(page, target_url):
    """Mô phỏng điều hướng giống con người đến trang đích"""
    
    # 1. Vào trang chủ
    await page.goto("https://example.com")
    await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 2. Đôi khi cuộn trang chủ
    if random.random() > 0.5:
        await page.evaluate("window.scrollBy(0, 300)")
        await page.wait_for_timeout(random.randint(1000, 2000))
    
    # 3. Sử dụng tìm kiếm hoặc điều hướng
    if random.random() > 0.3:
        search_box = await page.query_selector('input[type="search"]')
        if search_box:
            await search_box.type("search query", delay=100)
            await page.keyboard.press("Enter")
            await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 4. Chuyển đến trang đích
    await page.goto(target_url)
    
    # 5. Cuộn trang như con người
    await human_scroll(page)

async def human_scroll(page):
    """Mô phỏng cuộn trang giống con người"""
    scroll_height = await page.evaluate("document.body.scrollHeight")
    current_position = 0
    
    while current_position < scroll_height * 0.7:  # Không đến cuối
        scroll_amount = random.randint(200, 500)
        await page.evaluate(f"window.scrollBy(0, {scroll_amount})")
        current_position += scroll_amount
        await page.wait_for_timeout(random.randint(500, 1500))

Chuyển động chuột

Một số hệ thống theo dõi chuyển động chuột. Chuyển động thẳng từ điểm A đến điểm B — dấu hiệu của bot. Con người di chuyển chuột theo đường cong với các hiệu chỉnh vi mô:

import bezier
import numpy as np

def generate_human_mouse_path(start, end, num_points=50):
    """
    Tạo đường đi chuột giống con người,
    sử dụng đường cong Bezier với nhiễu nhỏ.
    """
    # Điểm kiểm soát cho đường cong Bezier
    control1 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.2, 0.4) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.2, 0.4) + random.randint(-50, 50)
    )
    control2 = (
        start[0] + (end[0] - start[0]) * random.uniform(0.6, 0.8) + random.randint(-50, 50),
        start[1] + (end[1] - start[1]) * random.uniform(0.6, 0.8) + random.randint(-50, 50)
    )
    
    # Tạo đường cong Bezier
    nodes = np.asfortranarray([
        [start[0], control1[0], control2[0], end[0]],
        [start[1], control1[1], control2[1], end[1]]
    ])
    curve = bezier.Curve(nodes, degree=3)
    
    # Tạo các điểm trên đường cong
    points = []
    for t in np.linspace(0, 1, num_points):
        point = curve.evaluate(t)
        # Thêm nhiễu vi mô
        x = point[0][0] + random.uniform(-2, 2)
        y = point[1][0] + random.uniform(-2, 2)
        points.append((x, y))
    
    return points

async def human_click(page, selector):
    """Nhấp vào phần tử với chuyển động chuột giống con người"""
    element = await page.query_selector(selector)
    box = await element.bounding_box()
    
    # Điểm đích — không phải tâm, mà là điểm ngẫu nhiên bên trong phần tử
    target_x = box['x'] + random.uniform(box['width'] * 0.2, box['width'] * 0.8)
    target_y = box['y'] + random.uniform(box['height'] * 0.2, box['height'] * 0.8)
    
    # Vị trí chuột hiện tại (hoặc vị trí bắt đầu ngẫu nhiên)
    start_x = random.randint(0, 1920)
    start_y = random.randint(0, 1080)
    
    # Tạo đường đi
    path = generate_human_mouse_path((start_x, start_y), (target_x, target_y))
    
    # Di chuyển chuột theo đường đi
    for x, y in path:
        await page.mouse.move(x, y)
        await page.wait_for_timeout(random.randint(5, 20))
    
    # Tạm dừng nhỏ trước khi nhấp
    await page.wait_for_timeout(random.randint(50, 150))
    await page.mouse.click(target_x, target_y)

Tải tài nguyên

Trình duyệt thực tế tải không chỉ HTML mà còn CSS, JavaScript, hình ảnh, phông chữ. Nếu bạn sử dụng requests và chỉ yêu cầu HTML — điều này đáng ngờ. Khi làm việc với headless-browser, vấn đề này được giải quyết tự động, nhưng khi sử dụng HTTP-client, bạn cần tính đến điều này.

Lựa chọn loại proxy cho nhiệm vụ

Các loại proxy khác nhau có các đặc điểm khác nhau và phù hợp cho các nhiệm vụ khác nhau. Lựa chọn sai — nguyên nhân thường xuyên của các lần chặn.

Proxy trung tâm dữ liệu

Proxy trung tâm dữ liệu — đây là địa chỉ IP thuộc về các nhà cung cấp lưu trữ. Chúng dễ xác định bằng cách thuộc về AS (hệ thống tự trị) của các trung tâm dữ liệu lớn.

Ưu điểm:

• Tốc độ và ổn định cao
• Chi phí thấp
• Nhóm IP lớn

Nhược điểm:

• Dễ phát hiện
• Thường trong danh sách đen
• Không phù hợp cho các trang web có bảo vệ nghiêm ngặt

Phù hợp cho: công cụ SEO, kiểm tra khả năng truy cập, làm việc với API không có bảo vệ nghiêm ngặt, thử nghiệm.

Proxy dân cư

Proxy dân cư — đây là địa chỉ IP của người dùng thực tế, được cung cấp thông qua các chương trình đối tác hoặc SDK trong các ứng dụng. Chúng thuộc về các nhà cung cấp dịch vụ internet thông thường (ISP).

Ưu điểm:

• Trông giống như người dùng thông thường
• Fraud score thấp
• Địa lý rộng
• Khó phát hiện

Nhược điểm:

• Chi phí cao hơn (thanh toán theo lưu lượng)
• Tốc độ phụ thuộc vào người dùng cuối
• IP có thể "biến mất" (người dùng tắt thiết bị)

Phù hợp cho: phân tích cú pháp các trang web được bảo vệ, làm việc với mạng xã hội, thương mại điện tử, bất kỳ nhiệm vụ nào mà việc không bị phát hiện là quan trọng.

Proxy di động

Proxy di động — đây là địa chỉ IP của các nhà mạng di động (MTS, Beeline, Megafon và các tương tự ở các quốc gia khác). Chúng có trạng thái đặc biệt do công nghệ CGNAT.

Ưu điểm:

• Lòng tin tối đa từ các trang web
• Một IP được sử dụng bởi hàng nghìn người dùng thực tế — khó cấm
• Lý tưởng để làm việc với tài khoản
• Thay đổi IP theo yêu cầu (kết nối lại mạng)

Nhược điểm:

• Chi phí cao nhất
• Tốc độ hạn chế
• Lựa chọn địa lý ít hơn

Phù hợp cho: đa tài khoản, làm việc với Instagram/Facebook/TikTok, đăng ký tài khoản, bất kỳ nhiệm vụ nào có rủi ro cao bị cấm.

Bảng so sánh

Kỹ thuật nâng cao để vượt qua bảo vệ

Khi các phương pháp cơ bản không hoạt động, bạn phải sử dụng các kỹ thuật phức tạp hơn. Hãy xem xét một số cách tiếp cận nâng cao.

Làm việc với Cloudflare và các bảo vệ tương tự

Cloudflare, Akamai, PerimeterX — các hệ thống này sử dụng các thử thách JavaScript để xác minh trình duyệt. Yêu cầu HTTP đơn giản sẽ không vượt qua. Các tùy chọn giải pháp:

1. Sử dụng trình duyệt thực:

from playwright.sync_api import sync_playwright

def bypass_cloudflare(url, proxy):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # Đôi khi headless bị phát hiện
            proxy={"server": proxy}
        )
        
        page = browser.new_page()
        page.goto(url)
        
        # Chờ vượt qua kiểm tra (thường 5-10 giây)
        page.wait_for_timeout(10000)
        
        # Kiểm tra xem chúng ta đã vượt qua hay chưa
        if "challenge" not in page.url:
            # Lưu cookies để sử dụng sau
            cookies = page.context.cookies()
            return cookies
        
        browser.close()
        return None

2. Sử dụng các giải pháp sẵn có:

# cloudscraper — thư viện để vượt qua Cloudflare
import cloudscraper

scraper = cloudscraper.create_scraper(
    browser={
        'browser': 'chrome',
        'platform': 'windows',
        'desktop': True
    }
)

scraper.proxies = {"http": proxy, "https": proxy}
response = scraper.get("https://protected-site.com")

Giải quyết captcha

Nếu trang web hiển thị captcha, có một số cách tiếp cận:

Dịch vụ nhận dạng: 2Captcha, Anti-Captcha, CapMonster. Họ giải quyết captcha cho bạn