Cara Mengurangi Tingkat Ban saat Web Scraping hingga 5%: 12 Metode Perlindungan Terbukti

Jika Anda melakukan parsing marketplace, memantau harga kompetitor, atau mengumpulkan data dari situs web, maka Anda tahu masalahnya: situs memblokir alamat IP, meminta captcha, atau mengembalikan halaman kosong. Ban rate (persentase permintaan yang diblokir) bisa mencapai 70-90%, yang membuat parsing menjadi tidak mungkin. Dalam artikel ini kita akan membahas metode konkret yang akan membantu menurunkan ban rate hingga 5-10% dan mengumpulkan data secara stabil.

Kita akan membahas solusi teknis (rotasi proxy, header HTTP, fingerprinting) maupun pola perilaku (jeda, meniru tindakan pengguna). Semua metode telah diuji dalam praktik saat parsing Wildberries, Ozon, Avito, dan platform luar negeri.

Mengapa situs memblokir parser: pemicu utama

Sebelum membahas metode perlindungan, penting untuk memahami bagaimana situs mendeteksi lalu lintas otomatis. Sistem anti-bot modern (Cloudflare, Akamai, DataDome, Imperva) menganalisis puluhan parameter dari setiap permintaan. Berikut adalah pemicu utama pemblokiran:

Misalnya, saat parsing Wildberries, kesalahan umum adalah mengirim permintaan setiap 0,5 detik dari satu IP. Sistem anti-bot Cloudflare akan langsung mendeteksi pola tersebut dan memblokir IP selama 24 jam. Pengguna nyata menghabiskan 5-15 detik untuk melihat kartu produk, scroll halaman, klik pada gambar.

Rotasi proxy: cara mengganti alamat IP dengan benar

Penggunaan proxy adalah metode dasar untuk menurunkan ban rate. Tetapi penting bukan hanya membeli proxy, melainkan mengkonfigurasi rotasi dengan benar. Berikut adalah strategi yang terbukti:

Memilih jenis proxy untuk parsing

Untuk parsing marketplace (Wildberries, Ozon, Avito) disarankan menggunakan proxy residensial — mereka memiliki IP pengguna rumahan nyata yang sulit dibedakan dari lalu lintas biasa. Proxy data center cocok untuk situs yang kurang terlindungi atau ketika diperlukan kecepatan maksimal dengan volume data besar.

Strategi rotasi alamat IP

Ukuran pool proxy

Ukuran pool minimum tergantung pada intensitas parsing:

• Intensitas rendah (hingga 10.000 permintaan per hari): 10-20 proxy
• Intensitas sedang (10.000 - 100.000 permintaan per hari): 50-100 proxy
• Intensitas tinggi (lebih dari 100.000 permintaan per hari): 200+ proxy atau residensial dengan rotasi otomatis

Untuk proxy residensial dengan rotasi pada setiap permintaan (rotating proxies), ukuran pool bisa lebih kecil, karena penyedia secara otomatis mengganti IP baru dari pool mereka yang berjumlah jutaan alamat.

User-Agent dan header HTTP: meniru browser nyata

Bahkan dengan proxy yang bagus, Anda bisa diblokir jika header HTTP terlihat mencurigakan. Situs menganalisis tidak hanya User-Agent, tetapi juga urutan header, nilainya, dan kesesuaian satu sama lain.

User-Agent yang benar

Jangan gunakan User-Agent yang sama untuk semua permintaan. Buat daftar browser populer dan pilih secara acak dari daftar tersebut:

user_agents = [
    # Chrome di Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    # Chrome di macOS
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
    # Firefox di Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
    # Safari di macOS
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15",
    # Edge di Windows
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36 Edg/120.0.0.0"
]

Set lengkap header HTTP

Browser modern mengirim 15-20 header. Berikut adalah set minimal yang diperlukan untuk meniru Chrome:

headers = {
    "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/120.0.0.0",
    "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
    "Accept-Language": "id-ID,id;q=0.9,en-US;q=0.8,en;q=0.7",
    "Accept-Encoding": "gzip, deflate, br",
    "DNT": "1",
    "Connection": "keep-alive",
    "Upgrade-Insecure-Requests": "1",
    "Sec-Fetch-Dest": "document",
    "Sec-Fetch-Mode": "navigate",
    "Sec-Fetch-Site": "none",
    "Sec-Fetch-User": "?1",
    "Cache-Control": "max-age=0",
    "sec-ch-ua": '"Not_A Brand";v="8", "Chromium";v="120", "Google Chrome";v="120"',
    "sec-ch-ua-mobile": "?0",
    "sec-ch-ua-platform": '"Windows"'
}

Perhatikan header Sec-Fetch-* dan sec-ch-ua-* — mereka muncul di versi Chrome terbaru dan ketiadaan mereka dapat mengungkap otomasi.

Urutan header itu penting

Browser mengirim header dalam urutan tertentu. Misalnya, Chrome selalu menempatkan Host pertama, kemudian Connection, User-Agent dan seterusnya. Jika Anda menggunakan library Python requests, urutannya mungkin alfabetis, yang akan mengungkap otomasi.

Solusi: gunakan library yang membentuk header dengan benar (curl_cffi untuk Python, got untuk Node.js) atau browser headless (Puppeteer, Playwright, Selenium) yang menghasilkan header seperti browser asli.

Jeda antar permintaan: interval optimal

Salah satu metode paling sederhana namun efektif untuk menurunkan ban rate adalah jeda yang tepat antar permintaan. Pengguna nyata tidak dapat membuka 10 halaman per detik, sehingga permintaan yang terlalu cepat langsung menyebabkan pemblokiran.

Jeda acak daripada tetap

Jangan gunakan jeda tetap (misalnya, tepat 2 detik antar permintaan). Sistem anti-bot mudah mendeteksi pola seperti itu. Gunakan interval acak:

import random
import time

# Daripada jeda tetap
time.sleep(2)  # ❌ Buruk

# Gunakan interval acak
delay = random.uniform(2.5, 5.5)  # ✅ Baik
time.sleep(delay)

Interval yang disarankan untuk berbagai situs

Jeda adaptif berdasarkan respons server

Pendekatan lanjutan — mengubah jeda secara dinamis tergantung pada respons server:

base_delay = 3.0  # Jeda dasar
delay_multiplier = 1.0

response = requests.get(url, headers=headers, proxies=proxies)

# Jika mendapat captcha atau 429 — tingkatkan jeda
if response.status_code == 429 or 'captcha' in response.text.lower():
    delay_multiplier *= 1.5
    print(f"Perlindungan terdeteksi, meningkatkan jeda menjadi {base_delay * delay_multiplier} detik")

# Jika semuanya baik — bisa sedikit dipercepat
elif response.status_code == 200:
    delay_multiplier = max(1.0, delay_multiplier * 0.95)

time.sleep(random.uniform(base_delay * delay_multiplier, base_delay * delay_multiplier * 1.5))

Pendekatan ini memungkinkan untuk otomatis melambat saat perlindungan terdeteksi dan mempercepat ketika situs tidak menunjukkan agresi.

Perlindungan dari fingerprinting: Canvas, WebGL, font

Jika situs menggunakan JavaScript untuk verifikasi, header HTTP sederhana tidak cukup. Sistem anti-bot modern membuat "sidik jari" browser (fingerprint) berdasarkan puluhan parameter: Canvas, WebGL, font yang terinstal, zona waktu, resolusi layar, dan lainnya.

Parameter utama fingerprinting

Alat untuk bypass fingerprinting

Untuk bypass fingerprinting gunakan alat khusus:

• Undetected ChromeDriver (Python) — versi modifikasi Selenium yang menyembunyikan tanda-tanda otomasi
• Puppeteer Stealth (Node.js) — plugin untuk Puppeteer yang mengganti parameter fingerprint
• Playwright dengan stealth — mirip Puppeteer, tetapi dengan dukungan lebih baik untuk berbagai browser
• Browser anti-deteksi (Dolphin Anty, AdsPower, Multilogin) — untuk mereka yang tidak ingin menulis kode, browser ini otomatis mengganti fingerprint

Contoh penggunaan undetected-chromedriver di Python:

import undetected_chromedriver as uc

# Buat browser dengan perlindungan dari deteksi
options = uc.ChromeOptions()
options.add_argument('--disable-blink-features=AutomationControlled')

driver = uc.Chrome(options=options)
driver.get('https://example.com')

# Periksa bahwa navigator.webdriver === undefined
webdriver_status = driver.execute_script("return navigator.webdriver")
print(f"navigator.webdriver: {webdriver_status}")  # Harus None/undefined

Pengelolaan cookies dan sesi

Banyak situs menggunakan cookies untuk melacak perilaku pengguna. Pengelolaan cookies yang benar membantu menghindari pemblokiran dan terlihat seperti pengguna nyata.

Menyimpan dan menggunakan kembali cookies

Daripada membuat sesi baru pada setiap permintaan, simpan cookies dan gunakan kembali. Ini meniru perilaku pengguna nyata yang kembali ke situs:

import requests
import pickle

session = requests.Session()

# Kunjungan pertama — dapatkan cookies
response = session.get('https://example.com')

# Simpan cookies ke file
with open('cookies.pkl', 'wb') as f:
    pickle.dump(session.cookies, f)

# Kemudian muat cookies
with open('cookies.pkl', 'rb') as f:
    session.cookies.update(pickle.load(f))

# Sekarang permintaan terlihat dari pengguna yang kembali
response = session.get('https://example.com/catalog')

Pemanasan sesi sebelum parsing

Jangan mulai parsing langsung dari halaman target. Tiru perilaku pengguna nyata:

1. Buka halaman utama situs
2. Tunggu 2-5 detik
3. Buka halaman kategori atau bagian
4. Tunggu 3-7 detik
5. Baru setelah itu mulai parsing halaman target

Ini menciptakan riwayat aktivitas di cookies dan mengurangi kemungkinan pemblokiran.

Penanganan session cookies dan token

Beberapa situs menghasilkan token unik pada kunjungan pertama dan memeriksanya dalam permintaan berikutnya. Misalnya, Wildberries menggunakan token di header x-requested-with. Selalu simpan token tersebut dari respons pertama dan kirim dalam permintaan berikutnya.

Rendering JavaScript: kapan diperlukan

Banyak situs modern memuat konten melalui JavaScript. Jika Anda menggunakan klien HTTP sederhana (requests di Python, axios di Node.js), Anda akan mendapatkan halaman kosong atau placeholder. Dalam kasus seperti itu diperlukan rendering JavaScript.

Kapan diperlukan rendering JavaScript

• Situs menggunakan React, Vue, Angular — konten dimuat setelah pemuatan halaman awal
• Data dimuat melalui permintaan AJAX/Fetch
• Situs memerlukan eksekusi JavaScript untuk menghasilkan token atau cookies
• Ada perlindungan dari bot yang memerlukan eksekusi kode JS (misalnya, Cloudflare Challenge)

Alat untuk rendering JavaScript

Untuk sebagian besar tugas disarankan Playwright — lebih cepat dari Selenium, lebih baik bypass perlindungan, dan memiliki API yang lebih nyaman.

Alternatif: intersepsi permintaan API

Sering kali Anda dapat menghindari rendering JavaScript jika menemukan permintaan API yang digunakan situs untuk memuat data. Buka DevTools (F12) → tab Network → filter XHR/Fetch dan lihat permintaan apa yang dikirim situs. Kemudian ulangi permintaan tersebut langsung melalui klien HTTP.

Contoh: Wildberries memuat data produk melalui API https://catalog.wb.ru/catalog/.... Daripada merender seluruh halaman, Anda dapat meminta API ini langsung, yang 10-20 kali lebih cepat.

Bypass captcha: solusi otomatis

Bahkan dengan proxy dan header yang benar, Anda mungkin menghadapi captcha. Ada beberapa pendekatan untuk menyelesaikannya:

Jenis captcha dan metode penyelesaian

Integrasi layanan pengenalan captcha

Contoh integrasi 2Captcha di Python:

from twocaptcha import TwoCaptcha

solver = TwoCaptcha('YOUR_API_KEY')

try:
    # Selesaikan reCAPTCHA v2
    result = solver.recaptcha(
        sitekey='6Le-wvkSAAAAAPBMRTvw0Q4Muexq9bi0DJwx_mJ-',
        url='https://example.com'
    )
    
    # Dapatkan token penyelesaian
    captcha_token = result['code']
    
    # Kirim formulir dengan token
    response = requests.post('https://example.com/submit', data={
        'g-recaptcha-response': captcha_token
    })
    
except Exception as e:
    print(f"Kesalahan penyelesaian captcha: {e}")

Rate limiting: cara tidak melebihi batas situs

Banyak situs memiliki batas eksplisit atau implisit pada jumlah permintaan. Melebihi batas ini menyebabkan pemblokiran IP sementara atau permanen.

Menentukan batas situs

Perhatikan header HTTP dalam respons server:

• X-RateLimit-Limit — jumlah maksimal permintaan dalam periode
• X-RateLimit-Remaining — berapa permintaan tersisa
• X-RateLimit-Reset — kapan batas akan direset (Unix timestamp)
• Retry-After — dalam berapa detik dapat mengulangi permintaan

Jika Anda mendapat kode status 429 (Too Many Requests), ini berarti melebihi batas. Baca header Retry-After dan tunggu waktu yang ditentukan sebelum permintaan berikutnya.

Implementasi rate limiter

Buat mekanisme kontrol kecepatan permintaan:

import time
from collections import deque

class RateLimiter:
    def __init__(self, max_requests, time_window):
        """
        max_requests: jumlah maksimal permintaan
        time_window: jendela waktu dalam detik
        """
        self.max_requests = max_requests
        self.time_window = time_window
        self.requests = deque()
    
    def wait_if_needed(self):
        now = time.time()
        
        # Hapus permintaan lama di luar jendela waktu
        while self.requests and self.requests[0] < now - self.time_window:
            self.requests.popleft()
        
        # Jika mencapai batas — tunggu
        if len(self.requests) >= self.max_requests:
            sleep_time = self.time_window - (now - self.requests[0])
            if sleep_time > 0:
                print(f"Batas tercapai, menunggu {sleep_time:.2f} detik")
                time.sleep(sleep_time)
                self.requests.clear()
        
        # Catat permintaan baru
        self.requests.append(time.time())

# Penggunaan: maksimal 100 permintaan per 60 detik
limiter = RateLimiter(max_requests=100, time_window=60)

for url in urls:
    limiter.wait_if_needed()
    response = requests.get(url)

Pemantauan metrik: melacak ban rate

Untuk mengoptimalkan strategi parsing, penting untuk memantau metrik kunci dan menganalisis pola pemblokiran.

Metrik utama untuk pemantauan

Contoh implementasi sistem pemantauan sederhana:

from collections import defaultdict
import time

class ScraperMetrics:
    def __init__(self):
        self.total_requests = 0
        self.successful_requests = 0
        self.blocked_requests = 0
        self.captcha_requests = 0
        self.status_codes = defaultdict(int)
        self.proxy_stats = defaultdict(lambda: {'success': 0, 'blocked': 0})
        self.start_time = time.time()
    
    def record_request(self, status_code, proxy=None, has_captcha=False):
        self.total_requests += 1
        self.status_codes[status_code] += 1
        
        if has_captcha:
            self.captcha_requests += 1
        
        if status_code == 200 and not has_captcha:
            self.successful_requests += 1
            if proxy:
                self.proxy_stats[proxy]['success'] += 1
        elif status_code in [403, 429] or has_captcha:
            self.blocked_requests += 1
            if proxy:
                self.proxy_stats[proxy]['blocked'] += 1
    
    def get_ban_rate(self):
        if self.total_requests == 0:
            return 0
        return (self.blocked_requests / self.total_requests) * 100
    
    def get_success_rate(self):
        if self.total_requests == 0:
            return 0
        return (self.successful_requests / self.total_requests) * 100
    
    def print_summary(self):
        runtime = time.time() - self.start_time
        print(f"\n{'='*50}")
        print(f"Ringkasan Metrik Scraping")
        print(f"{'='*50}")
        print(f"Total permintaan: {self.total_requests}")
        print(f"Berhasil: {self.successful_requests} ({self.get_success_rate():.2f}%)")
        print(f"Diblokir: {self.blocked_requests} ({self.get_ban_rate():.2f}%)")
        print(f"Captcha: {self.captcha_requests}")
        print(f"Waktu berjalan: {runtime:.2f} detik")
        print(f"Permintaan/detik: {self.total_requests/runtime:.2f}")
        print(f"\nDistribusi kode status:")
        for code, count in sorted(self.status_codes.items()):
            print(f"  {code}: {count}")

# Penggunaan
metrics = ScraperMetrics()

for url in urls:
    response = requests.get(url, proxies=proxy)
    has_captcha = 'captcha' in response.text.lower()
    metrics.record_request(response.status_code, proxy=proxy['http'], has_captcha=has_captcha)

metrics.print_summary()

Analisis pola pemblokiran

Berdasarkan metrik yang dikumpulkan, Anda dapat mengidentifikasi pola dan mengoptimalkan strategi:

• Jika ban rate tinggi pada jam tertentu — situs mungkin memiliki perlindungan yang lebih ketat pada jam sibuk. Parsing pada malam hari atau pagi hari.
• Jika proxy tertentu memiliki ban rate tinggi — IP tersebut mungkin sudah masuk daftar hitam. Hapus dari pool dan ganti dengan yang baru.
• Jika ban rate meningkat seiring waktu — situs mungkin mengidentifikasi pola Anda. Tingkatkan keacakan dalam jeda dan urutan permintaan.
• Jika banyak captcha tetapi sedikit blok 403/429 — fingerprint browser Anda terdeteksi. Tingkatkan perlindungan anti-deteksi.

Perbandingan alat untuk parsing

Memilih alat yang tepat dapat secara signifikan mempengaruhi ban rate dan kecepatan parsing. Berikut perbandingan solusi populer:

Rekomendasi pemilihan alat

Kesimpulan

Menurunkan ban rate saat web scraping adalah tugas kompleks yang memerlukan pendekatan terpadu. Tidak ada solusi universal — setiap situs memiliki sistem perlindungan sendiri dan memerlukan strategi individual.

Ingat bahwa web scraping harus mematuhi hukum dan ketentuan penggunaan situs. Selalu periksa file robots.txt, jangan membebani server secara berlebihan, dan hormati hak pemilik data.

Dengan pendekatan yang tepat dan kombinasi metode yang dijelaskan, Anda dapat menurunkan ban rate hingga 5-10% dan mengumpulkan data yang diperlukan secara stabil. Mulai dengan metode sederhana, pantau metrik, dan secara bertahap tingkatkan perlindungan berdasarkan respons situs.