Toplu İsteklerde Engellemeye Karşı Koruma: Teknikler ve Araçlar

Hesapların ve IP adreslerinin engellenmesi, parselleme, otomasyon ve sosyal medya üzerindeki toplu işlemler sırasında en büyük problemdir. Modern anti-bot sistemleri, istek sıklığından tarayıcı parmak izine kadar birçok parametreyi analiz eder. Bu kılavuzda, otomasyonu tespit etme mekanizmalarını ve bunları aşmanın pratik yollarını inceleyeceğiz.

Otomasyonu Tespit Etme Mekanizmaları

Modern koruma sistemleri, botları tespit etmek için çok katmanlı analiz kullanır. Bu mekanizmaların anlaşılması, doğru bir aşma stratejisi seçmek için kritik öneme sahiptir.

Analiz için Temel Parametreler

İstek Sıklığı (Request Rate): Bir insan fiziksel olarak dakikada 100 istek gönderemez. Sistemler, yalnızca toplam sayıyı değil, aynı zamanda zaman içindeki dağılımı da analiz eder — istekler arasındaki eşit aralıklar botu ortaya çıkarır.

Davranış Kalıpları: Eylem sırası, kaydırma derinliği, fare hareketleri, sayfada geçirilen süre. Gecikme olmadan bağlantılara anında geçen bir bot kolayca tanınır.

Teknik Parmak İzleri: User-Agent, HTTP başlıkları, başlık sırası, TLS parmak izi, Canvas/WebGL parmak izi. Bu parametrelerdeki tutarsızlıklar, anti-bot sistemleri için kırmızı bayraktır.

Oran Sınırlama ve İstek Sıklığı Kontrolü

İsteklerin gönderim hızını kontrol etmek, engellemeye karşı ilk savunma hattıdır. Proxy döngüsü ile bile, çok agresif bir parselleme engellemeye yol açabilir.

Dinamik Gecikmeler

Sabit aralıklar (örneğin, istekler arasında tam 2 saniye) kolayca tanınır. Normal dağılım ile rastgele gecikmeler kullanın:

import time
import random
import numpy as np

def human_delay(min_delay=1.5, max_delay=4.0, mean=2.5, std=0.8):
    """
    İnsan davranışını taklit eden normal dağılıma sahip gecikme üretimi
    """
    delay = np.random.normal(mean, std)
    # Aralığı sınırlama
    delay = max(min_delay, min(delay, max_delay))
    
    # Gerçekçilik için mikro gecikmeler ekleme
    delay += random.uniform(0, 0.3)
    
    time.sleep(delay)

# Kullanım
for url in urls:
    response = session.get(url)
    human_delay(min_delay=2, max_delay=5, mean=3, std=1)

Uyarlanabilir Oran Sınırlama

Daha gelişmiş bir yaklaşım, sunucu yanıtlarına dayalı olarak hızın uyarlanmasıdır. Eğer 429 (Too Many Requests) veya 503 kodları alıyorsanız, otomatik olarak hızı düşürün:

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=2.0):
        self.current_delay = initial_delay
        self.min_delay = 1.0
        self.max_delay = 30.0
        self.error_count = 0
        
    def wait(self):
        time.sleep(self.current_delay + random.uniform(0, 0.5))
        
    def on_success(self):
        # Başarılı isteklerde yavaşça hızlanma
        self.current_delay = max(
            self.min_delay, 
            self.current_delay * 0.95
        )
        self.error_count = 0
        
    def on_rate_limit(self):
        # Engelleme durumunda ani yavaşlama
        self.error_count += 1
        self.current_delay = min(
            self.max_delay,
            self.current_delay * (1.5 + self.error_count * 0.5)
        )
        print(f"Oran sınırlaması aşıldı. Yeni gecikme: {self.current_delay:.2f}s")

# Uygulama
limiter = AdaptiveRateLimiter(initial_delay=2.0)

for url in urls:
    limiter.wait()
    response = session.get(url)
    
    if response.status_code == 429:
        limiter.on_rate_limit()
        time.sleep(60)  # Tekrar denemeden önce bekleme
    elif response.status_code == 200:
        limiter.on_success()
    else:
        # Diğer hataların işlenmesi
        pass

Proxy Döngüsü ve IP Adresi Yönetimi

Toplu istekler için tek bir IP adresi kullanmak engellemeyi garanti eder. Proxy döngüsü yükü dağıtır ve tespit riskini azaltır.

Döngü Stratejileri

1. İstek Başına Döngü: Her istekte veya her N istekte IP değiştirme. Arama motorlarından parselleme için uygundur, burada her isteğin anonimliği önemlidir.

2. Zaman Başına Döngü: Her 5-15 dakikada bir IP değiştirme. Sosyal medya ile çalışırken etkilidir, burada oturumun istikrarı önemlidir.

3. Sticky Oturumlar: Tüm kullanıcı oturumu için tek bir IP kullanma (yetkilendirme, eylem sırası). CSRF koruması olan siteler için kritik öneme sahiptir.

import requests
from itertools import cycle

class ProxyRotator:
    def __init__(self, proxy_list, rotation_type='request', rotation_interval=10):
        """
        rotation_type: 'request' (her istek) veya 'time' (zaman başına)
        rotation_interval: istek sayısı veya saniye
        """
        self.proxies = cycle(proxy_list)
        self.current_proxy = next(self.proxies)
        self.rotation_type = rotation_type
        self.rotation_interval = rotation_interval
        self.request_count = 0
        self.last_rotation = time.time()
        
    def get_proxy(self):
        if self.rotation_type == 'request':
            self.request_count += 1
            if self.request_count >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.request_count = 0
                print(f"Proxy değiştirildi: {self.current_proxy}")
                
        elif self.rotation_type == 'time':
            if time.time() - self.last_rotation >= self.rotation_interval:
                self.current_proxy = next(self.proxies)
                self.last_rotation = time.time()
                print(f"Proxy değiştirildi: {self.current_proxy}")
                
        return {'http': self.current_proxy, 'https': self.current_proxy}

# Örnek kullanım
proxy_list = [
    'http://user:pass@proxy1.example.com:8000',
    'http://user:pass@proxy2.example.com:8000',
    'http://user:pass@proxy3.example.com:8000',
]

rotator = ProxyRotator(proxy_list, rotation_type='request', rotation_interval=5)

for url in urls:
    proxies = rotator.get_proxy()
    response = requests.get(url, proxies=proxies, timeout=10)

Proxy Türü Seçimi

Sosyal medya ve ciddi koruma sistemlerine sahip platformlarda toplu işlemler için konut proxy'leri kullanın. Bunlar, normal ev bağlantıları gibi görünür ve nadiren kara listelere girer. Veri merkezleri, hızın önemli olduğu daha az korumalı kaynaklar için uygundur.

Tarayıcı Parmak İzi ve TLS Parmak İzleri

IP döngüsü ile bile, teknik parmak izleri ve TLS bağlantısı ile tespit edilebilirsiniz. Bu parametreler, her istemci için benzersizdir ve taklit edilmesi zordur.

TLS Parmak İzi

HTTPS bağlantısı kurarken, istemci desteklenen şifreler ve uzantılarla birlikte ClientHello gönderir. Bu kombinasyon, her kütüphane için benzersizdir. Örneğin, Python requests OpenSSL kullanır, bu da Chrome'dan kolayca ayırt edilebilir.

Çözüm: Tarayıcı parmak izlerini taklit eden kütüphaneler kullanın. Python için curl_cffi, tls_client veya tam tarayıcı emülasyonu için playwright/puppeteer kullanabilirsiniz.

# Kurulum: pip install curl-cffi
from curl_cffi import requests

# Chrome 110'u taklit etme
response = requests.get(
    'https://example.com',
    impersonate="chrome110",
    proxies={'https': 'http://proxy:port'}
)

# Alternatif: tls_client
import tls_client

session = tls_client.Session(
    client_identifier="chrome_108",
    random_tls_extension_order=True
)

response = session.get('https://example.com')

HTTP/2 Parmak İzi

TLS'nin yanı sıra, anti-bot sistemleri HTTP/2 parametrelerini de analiz eder: başlık sırası, SETTINGS çerçevesi ayarları, akış öncelikleri. Standart kütüphaneler, Chrome veya Firefox'un başlık sırasını tam olarak takip etmez.

# Chrome için doğru başlık sırası
headers = {
    ':method': 'GET',
    ':authority': 'example.com',
    ':scheme': 'https',
    ':path': '/',
    'sec-ch-ua': '"Not_A Brand";v="8", "Chromium";v="120"',
    'sec-ch-ua-mobile': '?0',
    'sec-ch-ua-platform': '"Windows"',
    'upgrade-insecure-requests': '1',
    'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)...',
    'accept': 'text/html,application/xhtml+xml...',
    'sec-fetch-site': 'none',
    'sec-fetch-mode': 'navigate',
    'sec-fetch-user': '?1',
    'sec-fetch-dest': 'document',
    'accept-encoding': 'gzip, deflate, br',
    'accept-language': 'en-US,en;q=0.9',
}

Canvas ve WebGL Parmak İzleri

Tarayıcılar, GPU, sürücüler ve işletim sistemine bağlı olarak grafikleri farklı şekilde çizer. Siteler, benzersiz bir cihaz parmak izi oluşturmak için bunu kullanır. Headless tarayıcılar (Selenium, Puppeteer) kullanırken, otomasyon belirtilerini maskelemek önemlidir:

// Puppeteer: headless modunu gizleme
const puppeteer = require('puppeteer-extra');
const StealthPlugin = require('puppeteer-extra-plugin-stealth');

puppeteer.use(StealthPlugin());

const browser = await puppeteer.launch({
    headless: true,
    args: [
        '--disable-blink-features=AutomationControlled',
        '--no-sandbox',
        '--disable-setuid-sandbox',
        `--proxy-server=${proxyUrl}`
    ]
});

const page = await browser.newPage();

// navigator.webdriver'ı yeniden tanımlama
await page.evaluateOnNewDocument(() => {
    Object.defineProperty(navigator, 'webdriver', {
        get: () => false,
    });
});

Başlıklar, Çerezler ve Oturum Yönetimi

HTTP başlıkları ve çerezlerle doğru çalışma, gerçek bir kullanıcıyı taklit etmek için kritik öneme sahiptir. Bu parametrelerdeki hatalar, engellemelerin sık görülen nedenlerindendir.

Zorunlu Başlıklar

Chrome tarayıcısını taklit etmek için minimum başlık seti:

import requests

headers = {
    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
    'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,image/avif,image/webp,*/*;q=0.8',
    'Accept-Language': 'en-US,en;q=0.9',
    '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',
}

session = requests.Session()
session.headers.update(headers)

Çerez Yönetimi

Birçok site, ilk ziyarette takip çerezleri kurar ve sonraki isteklerde bunların varlığını kontrol eder. Çerezlerin eksikliği veya uyumsuzluğu, bot belirtisi olarak kabul edilir.

import requests
import pickle

class SessionManager:
    def __init__(self, session_file='session.pkl'):
        self.session_file = session_file
        self.session = requests.Session()
        self.load_session()
        
    def load_session(self):
        """Kaydedilmiş oturumu yükleme"""
        try:
            with open(self.session_file, 'rb') as f:
                cookies = pickle.load(f)
                self.session.cookies.update(cookies)
        except FileNotFoundError:
            pass
            
    def save_session(self):
        """Tekrar kullanım için çerezleri kaydetme"""
        with open(self.session_file, 'wb') as f:
            pickle.dump(self.session.cookies, f)
            
    def request(self, url, **kwargs):
        response = self.session.get(url, **kwargs)
        self.save_session()
        return response

# Kullanım
manager = SessionManager('instagram_session.pkl')
response = manager.request('https://www.instagram.com/explore/')

Referer ve Origin

Referer ve Origin başlıkları, kullanıcının nereden geldiğini gösterir. Bunların eksikliği veya yanlış değerleri, kırmızı bayraktır.

# Doğru sıralama: ana sayfa → kategori → ürün
session = requests.Session()

# Adım 1: ana sayfaya gitme
response = session.get('https://example.com/')

# Adım 2: kategoriye geçiş
response = session.get(
    'https://example.com/category/electronics',
    headers={'Referer': 'https://example.com/'}
)

# Adım 3: ürünü görüntüleme
response = session.get(
    'https://example.com/product/12345',
    headers={'Referer': 'https://example.com/category/electronics'}
)

İnsan Davranışını Taklit Etme

Teknik parametreler sadece işin yarısıdır. Modern anti-bot sistemleri, kullanıcıların sayfa ile nasıl etkileşimde bulunduğunu, ne kadar zaman harcadığını ve fare hareketlerini analiz eder.

Kaydırma ve Fare Hareketleri

Selenium veya Puppeteer kullanırken, rastgele fare hareketleri ve sayfa kaydırma ekleyin:

from selenium import webdriver
from selenium.webdriver.common.action_chains import ActionChains
import random
import time

def human_like_mouse_move(driver):
    """Sayfa üzerinde rastgele fare hareketi"""
    action = ActionChains(driver)
    
    for _ in range(random.randint(3, 7)):
        x = random.randint(0, 1000)
        y = random.randint(0, 800)
        action.move_by_offset(x, y)
        action.pause(random.uniform(0.1, 0.3))
    
    action.perform()

def human_like_scroll(driver):
    """Doğal kaydırma taklidi"""
    total_height = driver.execute_script("return document.body.scrollHeight")
    current_position = 0
    
    while current_position < total_height:
        # Rastgele kaydırma adımı
        scroll_step = random.randint(100, 400)
        current_position += scroll_step
        
        driver.execute_script(f"window.scrollTo(0, {current_position});")
        
        # Varyasyon ile bekleme
        time.sleep(random.uniform(0.5, 1.5))
        
        # Bazen biraz geri kaydırma (insanların yaptığı gibi)
        if random.random() < 0.2:
            back_scroll = random.randint(50, 150)
            current_position -= back_scroll
            driver.execute_script(f"window.scrollTo(0, {current_position});")
            time.sleep(random.uniform(0.3, 0.8))

# Kullanım
driver = webdriver.Chrome()
driver.get('https://example.com')

human_like_mouse_move(driver)
time.sleep(random.uniform(2, 4))
human_like_scroll(driver)

Sayfada Geçen Süre

Gerçek kullanıcılar sayfada zaman geçirir: içerikleri okur, görüntüleri inceler. Bağlantılara anında geçen bir bot kolayca tanınır.

def realistic_page_view(driver, url, min_time=5, max_time=15):
    """
    Aktiflik ile gerçekçi sayfa görüntüleme
    """
    driver.get(url)
    
    # Başlangıç gecikmesi (yükleme ve "okuma")
    time.sleep(random.uniform(2, 4))
    
    # Kaydırma
    human_like_scroll(driver)
    
    # Ekstra aktivite
    total_time = random.uniform(min_time, max_time)
    elapsed = 0
    
    while elapsed < total_time:
        action_choice = random.choice(['scroll', 'mouse_move', 'pause'])
        
        if action_choice == 'scroll':
            # Yukarı/aşağı küçük kaydırma
            scroll_amount = random.randint(-200, 300)
            driver.execute_script(f"window.scrollBy(0, {scroll_amount});")
            pause = random.uniform(1, 3)
            
        elif action_choice == 'mouse_move':
            human_like_mouse_move(driver)
            pause = random.uniform(0.5, 2)
            
        else:  # pause
            pause = random.uniform(2, 5)
        
        time.sleep(pause)
        elapsed += pause

Navigasyon Kalıpları

Şüpheli kalıplardan kaçının: derin sayfalara doğrudan geçişler, ana sayfayı göz ardı etme, tüm öğeleri atlamadan sırayla gezme.

Cloudflare, DataDome ve Diğer Koruma Sistemlerini Aşma

Uzmanlaşmış anti-bot sistemleri, kapsamlı bir yaklaşım gerektirir. JavaScript zorlukları, CAPTCHA, gerçek zamanlı davranış analizi kullanırlar.

Cloudflare

Cloudflare, birkaç koruma katmanı kullanır: Tarayıcı Bütünlüğü Kontrolü, JavaScript Zorluğu, CAPTCHA. Temel korumayı aşmak için doğru bir TLS parmak izine ve JavaScript'i çalıştırmaya yeter:

# Seçenek 1: cloudscraper (JS zorluklarını otomatik çözme)
import cloudscraper

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

response = scraper.get('https://protected-site.com')

# Seçenek 2: undetected-chromedriver (zor durumlar için)
import undetected_chromedriver as uc

options = uc.ChromeOptions()
options.add_argument('--proxy-server=http://proxy:port')

driver = uc.Chrome(options=options)
driver.get('https://protected-site.com')

# Zorluğun geçmesini bekleme
time.sleep(5)

# İstekler için çerezleri alma
cookies = driver.get_cookies()
session = requests.Session()
for cookie in cookies:
    session.cookies.set(cookie['name'], cookie['value'])

DataDome

DataDome, kullanıcı davranışını gerçek zamanlı olarak analiz eder: fare hareketleri, klavye yazım tarzı, zamanlamalar. Aşmak için tam bir tarayıcı ve aktivite taklidi gereklidir:

from playwright.sync_api import sync_playwright
import random

def bypass_datadome(url, proxy=None):
    with sync_playwright() as p:
        browser = p.chromium.launch(
            headless=False,  # DataDome headless'i tespit eder
            proxy={'server': proxy} if proxy else None
        )
        
        context = browser.new_context(
            viewport={'width': 1920, 'height': 1080},
            user_agent='Mozilla/5.0 (Windows NT 10.0; Win64; x64)...'
        )
        
        page = context.new_page()
        
        # Otomasyonu maskelemek için script enjeksiyonu
        page.add_init_script("""
            Object.defineProperty(navigator, 'webdriver', {get: () => false});
            window.chrome = {runtime: {}};
        """)
        
        page.goto(url)
        
        # İnsan davranışını taklit etme
        time.sleep(random.uniform(2, 4))
        
        # Rastgele fare hareketleri
        for _ in range(random.randint(5, 10)):
            page.mouse.move(
                random.randint(100, 1800),
                random.randint(100, 1000)
            )
            time.sleep(random.uniform(0.1, 0.3))
        
        # Kaydırma
        page.evaluate(f"window.scrollTo(0, {random.randint(300, 800)})")
        time.sleep(random.uniform(1, 2))
        
        content = page.content()
        browser.close()
        
        return content

CAPTCHA

CAPTCHA'yı otomatik olarak çözmek için tanıma hizmetlerini (2captcha, Anti-Captcha) veya kaçınma stratejilerini kullanın:

• CAPTCHA tetiklemeyecek bir seviyeye kadar istek sıklığını azaltın
• İyi bir itibara sahip temiz konut IP'leri kullanın
• Yetkilendirilmiş hesaplar üzerinden çalışın (CAPTCHA eşiği daha yüksektir)
• Yükü zamana yayarak dağıtın (zirve saatlerden kaçının)

İzleme ve Engellemeleri Yönetme

En iyi uygulamalara rağmen, engellemeler kaçınılmazdır. Bunları hızlı bir şekilde tespit etmek ve doğru bir şekilde yönetmek önemlidir.

Engelleme Göstergeleri

Yeniden Deneme Sistemi

import requests
from requests.adapters import HTTPAdapter
from requests.packages.urllib3.util.retry import Retry

def create_session_with_retries():
    """
    Otomatik tekrarlar ve hata yönetimi ile oturum
    """
    session = requests.Session()
    
    retry_strategy = Retry(
        total=5,
        backoff_factor=2,  # 2, 4, 8, 16, 32 saniye
        status_forcelist=[429, 500, 502, 503, 504],
        method_whitelist=["GET", "POST"]
    )
    
    adapter = HTTPAdapter(max_retries=retry_strategy)
    session.mount("http://", adapter)
    session.mount("https://", adapter)
    
    return session

def safe_request(url, session, max_attempts=3):
    """
    Engellemeleri yönetme ile istek
    """
    for attempt in range(max_attempts):
        try:
            response = session.get(url, timeout=15)
            
            # Engellemeyi kontrol etme
            if response.status_code == 403:
                print(f"IP engellendi. Proxy değiştiriliyor...")
                # Proxy değiştirme mantığı
                continue
                
            elif response.status_code == 429:
                wait_time = int(response.headers.get('Retry-After', 60))
                print(f"Oran sınırlaması. {wait_time}s bekleniyor...")
                time.sleep(wait_time)
                continue
                
            elif 'captcha' in response.text.lower():
                print("CAPTCHA tespit edildi")
                # CAPTCHA çözme veya atlama mantığı
                return None
                
            return response
            
        except requests.exceptions.Timeout:
            print(f"{attempt + 1}. denemede zaman aşımı")
            time.sleep(5 * (attempt + 1))
            
        except requests.exceptions.ProxyError:
            print("Proxy hatası. Değiştiriliyor...")
            # Proxy değiştirme
            continue
            
    return None

Günlükleme ve Analiz

Stratejiyi optimize etmek için metrikleri izleyin:

import logging
from collections import defaultdict
from datetime import datetime

class ScraperMetrics:
    def __init__(self):
        self.stats = {
            'total_requests': 0,
            'successful': 0,
            'rate_limited': 0,
            'blocked': 0,
            'captcha': 0,
            'errors': 0,
            'proxy_failures': defaultdict(int)
        }
        
    def log_request(self, status, proxy=None):
        self.stats['total_requests'] += 1
        
        if status == 200:
            self.stats['successful'] += 1
        elif status == 429:
            self.stats['rate_limited'] += 1
        elif status == 403:
            self.stats['blocked'] += 1
            if proxy:
                self.stats['proxy_failures'][proxy] += 1
                
    def get_success_rate(self):
        if self.stats['total_requests'] == 0:
            return 0
        return (self.stats['successful'] / self.stats['total_requests']) * 100
        
    def print_report(self):
        print(f"\n=== Parselleme Raporu ===")
        print(f"Toplam istek: {self.stats['total_requests']}")
        print(f"Başarı oranı: {self.get_success_rate():.2f}%")
        print(f"Oran sınırlaması: {self.stats['rate_limited']}")
        print(f"Engellenen: {self.stats['blocked']}")
        print(f"CAPTCHA: {self.stats['captcha']}")
        
        if self.stats['proxy_failures']:
            print(f"\nSorunlu proxy'ler:")
            for proxy, count in sorted(
                self.stats['proxy_failures'].items(), 
                key=lambda x: x[1], 
                reverse=True
            )[:5]:
                print(f"  {proxy}: {count} başarısızlık")

# Kullanım
metrics = ScraperMetrics()

for url in urls:
    response = safe_request(url, session)
    if response:
        metrics.log_request(response.status_code, current_proxy)
    
metrics.print_report()

Sonuç

Koruma sistemlerini aşmak karmaşık bir süreçtir ve sürekli olarak güncellenen teknikler gerektirir. Yukarıda belirtilen yöntemleri ve stratejileri kullanarak, toplu isteklerde engellemeleri aşma şansınızı artırabilirsiniz. Ancak her zaman dikkatli olmalı ve etik kurallara uymalısınız.