Apa yang harus dilakukan jika proxy terus-menerus dilarang: panduan lengkap untuk diagnosis dan pemecahan masalah

Pemblokiran proxy yang terus-menerus adalah salah satu masalah paling umum dalam web scraping, otomasi, dan bekerja dengan beberapa akun. Dalam artikel ini, kami akan menganalisis mengapa hal ini terjadi dan cara menyelesaikan masalah secara sistematis, bukan hanya mengganti penyedia dengan harapan keajaiban.

Mengapa proxy benar-benar dilarang

Sebelum mencari solusi, Anda perlu memahami mekanisme pemblokiran. Sistem anti-fraud modern menggunakan perlindungan berlapis, dan pemblokiran proxy hanyalah konsekuensi, bukan penyebabnya. Memahami cara kerja sistem ini memungkinkan Anda membangun strategi bypass yang efektif.

Reputasi IP dan daftar hitam

Setiap alamat IP memiliki reputasi yang dibentuk berdasarkan riwayat penggunaannya. Jika alamat tersebut sebelumnya digunakan untuk spam, serangan DDoS, atau web scraping masif, alamat tersebut akan masuk ke database seperti Spamhaus, SORBS, atau daftar proprietary dari layanan tertentu. Ketika Anda terhubung melalui IP seperti itu, sistem segera mencurigai Anda.

Proxy data center sangat rentan terhadap masalah ini. Seluruh subnet dapat ditandai sebagai "hosting", dan lalu lintas apa pun dari mereka secara otomatis mendapat tingkat pemeriksaan yang lebih tinggi. Amazon AWS, Google Cloud, DigitalOcean — rentang IP mereka terkenal dan sering diblokir secara preventif.

Anda dapat memeriksa reputasi IP melalui layanan seperti IPQualityScore, Scamalytics, atau AbuseIPDB. Jika proxy Anda menunjukkan fraud score lebih tinggi dari 75, masalahnya ada di sini — ubah penyedia atau jenis proxy.

Pola permintaan

Manusia tidak membuat 100 permintaan per detik. Manusia tidak menavigasi halaman dengan periodisitas sempurna 2 detik. Manusia tidak mengabaikan gambar, CSS, dan JavaScript, hanya meminta HTML. Sistem anti-fraud menganalisis pola ini, dan setiap penyimpangan dari perilaku "manusia" meningkatkan risiko pemblokiran.

Statistik waktu antar permintaan sangat informatif. Jika Anda memiliki interval stabil — ini adalah tanda jelas otomasi. Menambahkan penundaan acak (misalnya, 1 hingga 5 detik) secara signifikan mengurangi kemungkinan deteksi.

Ketidaksesuaian metadata

Ketika User-Agent Anda mengatakan Anda menggunakan Chrome di Windows, tetapi header HTTP mengungkapkan karakteristik Python requests — ini adalah bendera merah. Ketika alamat IP berada di Jerman, tetapi pengaturan bahasa browser menunjukkan Rusia — bendera merah lainnya. Ketika zona waktu di JavaScript tidak cocok dengan geografi IP — bendera ketiga.

Akumulasi ketidaksesuaian ini menyebabkan sistem mengklasifikasikan koneksi sebagai mencurigakan dan menerapkan tindakan perlindungan: dari captcha hingga pemblokiran IP lengkap.

Browser fingerprint

Sistem perlindungan modern mengumpulkan puluhan parameter browser: resolusi layar, font yang diinstal, plugin, rendering WebGL, audio context, dan banyak lagi. Kombinasi parameter ini menciptakan "sidik jari" unik yang tetap konstan bahkan ketika IP berubah.

Jika Anda mengubah proxy tetapi fingerprint tetap sama, sistem memahami bahwa ini adalah pengguna yang sama. Dan jika satu fingerprint muncul dari ratusan IP berbeda dalam waktu singkat — ini adalah tanda jelas otomasi.

Diagnosis: cara memahami penyebab pemblokiran

Sebelum mengubah pengaturan secara sembarangan, lakukan diagnosis. Ini akan menghemat berjam-jam eksperimen dan membantu menemukan penyebab sebenarnya dari masalah. Pendekatan sistematis untuk diagnosis adalah kunci untuk menyelesaikan masalah secara efektif.

Langkah 1: Periksa proxy itu sendiri

Mulai dengan pemeriksaan dasar fungsionalitas proxy terlepas dari skrip utama Anda:

import requests

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

# Periksa fungsionalitas dasar
try:
    response = requests.get("https://httpbin.org/ip", proxies=proxy, timeout=10)
    print(f"IP melalui proxy: {response.json()['origin']}")
except Exception as e:
    print(f"Kesalahan koneksi: {e}")

# Periksa kebocoran IP asli
response = requests.get("https://browserleaks.com/ip", proxies=proxy)
# Bandingkan dengan IP asli Anda

Jika proxy tidak berfungsi bahkan pada permintaan sederhana — masalahnya ada pada proxy itu sendiri atau kredensial. Periksa format koneksi yang benar, ketersediaan dana di akun, dan batas penyedia.

Langkah 2: Periksa reputasi IP

Gunakan beberapa layanan untuk penilaian komprehensif:

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

# Periksa di layanan ini:
# 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"Periksa IP {proxy_ip} di layanan di atas")

Perhatikan indikator berikut: fraud score (harus di bawah 50), jenis IP (residential lebih baik daripada datacenter), kehadiran di daftar hitam. Jika IP ditandai sebagai VPN/Proxy — banyak situs akan mencurigainya sejak awal.

Langkah 3: Isolasi masalah

Coba proxy yang sama di situs target yang berbeda. Jika pemblokiran terjadi di mana-mana — masalahnya ada pada proxy atau konfigurasi Anda. Jika hanya di situs tertentu — masalahnya ada pada perlindungan situs itu atau perilaku Anda di sana.

Juga coba proxy berbeda di satu situs. Jika semuanya diblokir — masalahnya bukan pada proxy, tetapi pada skrip, fingerprint, atau pola perilaku Anda. Ini adalah tes yang sangat penting yang sering diabaikan banyak orang.

Langkah 4: Analisis respons server

Jenis pemblokiran yang berbeda memanifestasikan diri dengan cara yang berbeda. Pelajari cara membedakannya:

def analyze_response(response):
    status = response.status_code
    
    if status == 403:
        print("Akses ditolak — mungkin IP dalam daftar hitam")
    elif status == 429:
        print("Terlalu banyak permintaan — kurangi frekuensi")
    elif status == 503:
        print("Layanan tidak tersedia — mungkin perlindungan DDoS")
    elif status == 407:
        print("Diperlukan otorisasi proxy — periksa kredensial")
    elif "captcha" in response.text.lower():
        print("Captcha terdeteksi — mencurigai bot")
    elif "blocked" in response.text.lower():
        print("Pemblokiran eksplisit — ubah IP dan tinjau kembali pendekatan")
    elif len(response.text) < 1000:
        print("Respons mencurigakan pendek — mungkin stub")
    else:
        print(f"Status {status}, panjang respons: {len(response.text)}")

Rotasi yang tepat: frekuensi, logika, implementasi

Rotasi proxy bukan hanya "ubah IP lebih sering". Rotasi yang tidak tepat dapat membahayakan lebih dari tidak adanya rotasi sama sekali. Mari kita lihat strategi berbeda dan kapan menggunakannya.

Strategi 1: Rotasi berdasarkan jumlah permintaan

Pendekatan paling sederhana — ubah IP setelah jumlah permintaan tertentu. Cocok untuk web scraping di mana sesi tidak diperlukan:

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:
            # Tambahkan keacakan dalam jumlah permintaan
            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

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

Perhatikan keacakan dalam jumlah permintaan per proxy. Angka tetap (misalnya, tepat 50) adalah pola yang dapat dideteksi. Rentang acak membuat perilaku kurang dapat diprediksi.

Strategi 2: Rotasi berdasarkan waktu

Untuk tugas di mana sesi penting (misalnya, bekerja dengan akun), lebih baik mengikat IP ke waktu:

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)
            # Interval acak hingga rotasi berikutnya
            interval = random.randint(self.min_seconds, self.max_seconds)
            self.rotation_time = current_time + interval
            print(f"Proxy baru, rotasi berikutnya dalam {interval//60} menit")
        
        return self.current_proxy

Strategi 3: Sesi lengket untuk akun

Saat bekerja dengan beberapa akun, sangat penting bahwa setiap akun menggunakan IP yang konstan. Mengubah IP untuk akun yang masuk — jalan pasti menuju pemblokiran:

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):
        # Jika akun sudah memiliki proxy yang ditugaskan — kembalikan
        if account_id in self.account_proxies:
            return self.account_proxies[account_id]
        
        # Temukan proxy gratis
        available = [p for p in self.proxy_pool if p not in self.used_proxies]
        
        if not available:
            raise Exception("Tidak ada proxy gratis untuk akun baru")
        
        proxy = random.choice(available)
        self.account_proxies[account_id] = proxy
        self.used_proxies.add(proxy)
        
        return proxy
    
    def release_account(self, account_id):
        """Membebaskan proxy saat menghapus akun"""
        if account_id in self.account_proxies:
            proxy = self.account_proxies.pop(account_id)
            self.used_proxies.discard(proxy)

# Penggunaan
manager = AccountProxyManager(residential_proxy_list)

for account in accounts:
    proxy = manager.get_proxy_for_account(account.id)
    # Semua tindakan akun ini melalui satu IP

Strategi 4: Rotasi adaptif

Pendekatan paling canggih — ubah proxy sebagai respons terhadap sinyal dari situs target:

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}  # "Kesehatan" proxy awal
    
    def get_proxy(self):
        return self.current_proxy
    
    def report_result(self, success, response_code=200):
        """Dipanggil setelah setiap permintaan"""
        if success and response_code == 200:
            # Permintaan berhasil — sedikit naikkan skor
            self.proxy_scores[self.current_proxy] = min(100, 
                self.proxy_scores[self.current_proxy] + 1)
        elif response_code == 429:
            # Batas laju — turunkan banyak dan rotasi
            self.proxy_scores[self.current_proxy] -= 30
            self._rotate()
        elif response_code == 403:
            # Pemblokiran — nolkan skor dan rotasi
            self.proxy_scores[self.current_proxy] = 0
            self._rotate()
        elif response_code == 503:
            # Kemungkinan perlindungan — turunkan dan rotasi
            self.proxy_scores[self.current_proxy] -= 20
            self._rotate()
    
    def _rotate(self):
        # Pilih proxy dengan skor terbaik
        available = [(p, s) for p, s in self.proxy_scores.items() if s > 20]
        if not available:
            # Semua proxy "mati" — reset skor
            self.proxy_scores = {p: 50 for p in self.proxies}
            available = list(self.proxy_scores.items())
        
        # Pilihan tertimbang berdasarkan skor
        self.current_proxy = max(available, key=lambda x: x[1])[0]
        print(f"Rotasi ke proxy dengan skor {self.proxy_scores[self.current_proxy]}")

Browser fingerprint dan perannya dalam pemblokiran

Fingerprint adalah kombinasi karakteristik browser yang memungkinkan identifikasi pengguna bahkan tanpa cookie. Jika Anda mengubah IP tetapi fingerprint tetap sama, sistem perlindungan dengan mudah menghubungkan semua sesi Anda bersama-sama.

Dari apa fingerprint terdiri

Fingerprint modern mencakup puluhan parameter. Berikut adalah kategori utama:

Konsistensi fingerprint dan IP

Sangat penting bahwa fingerprint sesuai dengan geografi IP. Jika proxy berada di Jerman, fingerprint harus terlihat seperti pengguna Jerman:

// Contoh ketidaksesuaian (BURUK):
// IP: Jerman
// Timezone: America/New_York
// Languages: ["ru-RU", "ru"]
// Ini akan menimbulkan kecurigaan

// Fingerprint yang konsisten (BAIK):
// IP: Jerman
// Timezone: Europe/Berlin
// Languages: ["de-DE", "de", "en-US", "en"]

Alat untuk mengelola fingerprint

Untuk pekerjaan serius, gunakan alat khusus:

Playwright dengan 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)  # Terapkan patch stealth
    
    page.goto("https://target-site.com")

Puppeteer dengan 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();

// Ganti ulang timezone
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(Intl.DateTimeFormat.prototype, 'resolvedOptions', {
        value: function() {
            return { timeZone: 'Europe/Berlin' };
        }
    });
});

Browser anti-deteksi

Untuk bekerja dengan akun, sering digunakan browser anti-deteksi (Multilogin, GoLogin, Dolphin Anty, dan lainnya). Mereka memungkinkan Anda membuat profil terisolasi dengan fingerprint unik. Setiap profil memiliki set parameternya sendiri, cookie, localStorage — lingkungan yang sepenuhnya terisolasi.

Keuntungan anti-deteksi — mereka menyelesaikan masalah fingerprint "dari kotak". Kerugian — biaya dan kompleksitas otomasi (meskipun banyak yang memiliki API).

Pola perilaku: cara tidak terlihat seperti bot

Bahkan dengan fingerprint sempurna dan IP bersih, Anda bisa mendapat pemblokiran karena perilaku yang tidak manusiawi. Sistem modern menganalisis tidak hanya parameter teknis, tetapi juga pola interaksi dengan situs.

Penundaan waktu

Manusia tidak membuat permintaan dengan interval konstan. Tambahkan penundaan acak dengan distribusi normal:

import random
import time
import numpy as np

def human_delay(min_sec=1, max_sec=5, mean=2.5):
    """
    Menghasilkan penundaan yang terlihat manusiawi.
    Menggunakan distribusi lognormal — 
    sebagian besar penundaan pendek, tetapi kadang-kadang ada yang panjang.
    """
    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():
    """Penundaan antara penekanan tombol saat mengetik teks"""
    return random.uniform(0.05, 0.25)

# Penggunaan
for url in urls:
    response = requests.get(url, proxies=proxy)
    process(response)
    time.sleep(human_delay())  # Jeda acak antar permintaan

Meniru navigasi

Manusia tidak langsung menuju halaman produk melalui tautan langsung. Dia masuk ke beranda, menggunakan pencarian, melihat kategori. Tiru jalur ini:

async def human_like_navigation(page, target_url):
    """Meniru navigasi manusia ke halaman target"""
    
    # 1. Masuk ke beranda
    await page.goto("https://example.com")
    await page.wait_for_timeout(random.randint(2000, 4000))
    
    # 2. Kadang-kadang gulir beranda
    if random.random() > 0.5:
        await page.evaluate("window.scrollBy(0, 300)")
        await page.wait_for_timeout(random.randint(1000, 2000))
    
    # 3. Gunakan pencarian atau navigasi
    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. Buka halaman target
    await page.goto(target_url)
    
    # 5. Gulir halaman seperti manusia
    await human_scroll(page)

async def human_scroll(page):
    """Meniru pengguliran manusia"""
    scroll_height = await page.evaluate("document.body.scrollHeight")
    current_position = 0
    
    while current_position < scroll_height * 0.7:  # Tidak sepenuhnya
        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))

Gerakan mouse

Beberapa sistem melacak gerakan mouse. Gerakan lurus dari titik A ke titik B adalah tanda bot. Manusia menggerakkan mouse dalam kurva dengan koreksi mikro:

import bezier
import numpy as np

def generate_human_mouse_path(start, end, num_points=50):
    """
    Menghasilkan jalur mouse yang terlihat manusiawi,
    menggunakan kurva Bezier dengan sedikit noise.
    """
    # Titik kontrol untuk kurva 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)
    )
    
    # Buat kurva 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)
    
    # Hasilkan poin pada kurva
    points = []
    for t in np.linspace(0, 1, num_points):
        point = curve.evaluate(t)
        # Tambahkan mikro-noise
        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):
    """Klik elemen dengan gerakan mouse yang manusiawi"""
    element = await page.query_selector(selector)
    box = await element.bounding_box()
    
    # Titik target — bukan pusat, tetapi titik acak di dalam elemen
    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)
    
    # Posisi mouse saat ini (atau awal acak)
    start_x = random.randint(0, 1920)
    start_y = random.randint(0, 1080)
    
    # Hasilkan jalur
    path = generate_human_mouse_path((start_x, start_y), (target_x, target_y))
    
    # Gerakkan mouse di sepanjang jalur
    for x, y in path:
        await page.mouse.move(x, y)
        await page.wait_for_timeout(random.randint(5, 20))
    
    # Jeda kecil sebelum klik
    await page.wait_for_timeout(random.randint(50, 150))
    await page.mouse.click(target_x, target_y)

Memuat sumber daya

Browser nyata memuat tidak hanya HTML, tetapi juga CSS, JavaScript, gambar, font. Jika Anda menggunakan requests dan hanya meminta HTML — ini mencurigakan. Saat bekerja dengan headless-browser, masalah ini diselesaikan secara otomatis, tetapi saat menggunakan klien HTTP, Anda perlu mempertimbangkan hal ini.

Memilih jenis proxy untuk tugas Anda

Jenis proxy yang berbeda memiliki karakteristik berbeda dan cocok untuk tugas yang berbeda. Pilihan yang salah adalah penyebab umum pemblokiran.

Proxy data center

Proxy data center adalah alamat IP yang dimiliki oleh penyedia hosting. Mereka mudah diidentifikasi berdasarkan keanggotaan AS (Sistem Otonom) dari data center besar.

Kelebihan:

• Kecepatan dan stabilitas tinggi
• Biaya rendah
• Kumpulan IP besar

Kekurangan:

• Mudah dideteksi
• Sering dalam daftar hitam
• Tidak cocok untuk situs dengan perlindungan serius

Cocok untuk: alat SEO, pemeriksaan ketersediaan, bekerja dengan API tanpa perlindungan ketat, pengujian.

Proxy residensial

Proxy residensial adalah alamat IP dari pengguna nyata, disediakan melalui program afiliasi atau SDK dalam aplikasi. Mereka dimiliki oleh penyedia internet biasa (ISP).

Kelebihan:

• Terlihat seperti pengguna biasa
• Skor fraud rendah
• Geografi luas
• Sulit dideteksi

Kekurangan:

• Biaya lebih tinggi (pembayaran untuk lalu lintas)
• Kecepatan tergantung pada pengguna akhir
• IP dapat "hilang" (pengguna mematikan perangkat)

Cocok untuk: parsing situs yang dilindungi, bekerja dengan media sosial, e-commerce, tugas apa pun di mana penting untuk tidak terdeteksi.

Proxy mobile

Proxy mobile adalah alamat IP dari operator seluler (MTS, Beeline, Megafon dan analog di negara lain). Mereka memiliki status khusus karena teknologi CGNAT.

Kelebihan:

• Kepercayaan maksimal dari situs
• Satu IP digunakan oleh ribuan pengguna nyata — sulit untuk dilarang
• Ideal untuk bekerja dengan akun
• Perubahan IP atas permintaan (reconnect ke jaringan)

Kekurangan:

• Biaya tertinggi
• Kecepatan terbatas
• Pilihan geografi lebih sedikit

Cocok untuk: multi-akun, bekerja dengan Instagram/Facebook/TikTok, registrasi akun, tugas apa pun dengan risiko pemblokiran tinggi.

Tabel perbandingan

Teknik lanjutan untuk melewati perlindungan

Ketika metode dasar tidak berhasil, Anda perlu menggunakan teknik yang lebih kompleks. Mari kita lihat beberapa pendekatan lanjutan.

Bekerja dengan Cloudflare dan perlindungan serupa

Cloudflare, Akamai, PerimeterX — sistem ini menggunakan tantangan JavaScript untuk memverifikasi browser. Permintaan HTTP sederhana tidak akan lulus. Opsi solusi:

1. Menggunakan browser nyata:

from playwright.sync_api import sync_playwright

def bypass_cloudflare(url, proxy):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # Kadang-kadang headless terdeteksi
            proxy={"server": proxy}
        )
        
        page = browser.new_page()
        page.goto(url)
        
        # Tunggu verifikasi selesai (biasanya 5-10 detik)
        page.wait_for_timeout(10000)
        
        # Periksa apakah kami lulus
        if "challenge" not in page.url:
            # Simpan cookie untuk permintaan berikutnya
            cookies = page.context.cookies()
            return cookies
        
        browser.close()
        return None

2. Menggunakan solusi siap pakai:

# cloudscraper — perpustakaan untuk melewati 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")

Menyelesaikan captcha

Jika situs menampilkan captcha, ada beberapa pendekatan:

Layanan pengenalan: 2Captcha, Anti-Captcha, CapMonster. Mereka menyelesaikan captcha untuk Anda