API oran sınırlamasını proxy ile aşmanın yolları: IP rotasyonu ayarları ve seçim rehberi

Parser'ınızı ayarladınız, proxy'yi bağladınız ama API yine de 429 "Too Many Requests" hatası mı veriyor veya erişimi mi engelliyor? Sorun, proxy'lerin kendisinde değil, bunların yanlış kullanım stratejisindedir. Rate limiting, API'nin belirli bir süre içinde bir IP adresinden gelen istek sayısını sınırlayan bir koruma mekanizmasıdır. Bu yazıda, proxy üzerinden çalışırken neden engellemelerin ortaya çıktığını ve limitleri aşmak için sistemi nasıl doğru bir şekilde ayarlayacağımızı inceleyeceğiz.

API rate limiting nedir ve nasıl çalışır

Rate limiting (istek sıklığı sınırlaması), API'leri aşırı yüklenmelerden ve kötüye kullanımlardan korumak için bir mekanizmadır. Servis, belirli bir zaman diliminde bir kaynaktan yapılabilecek istek sayısını sınırlar. Örneğin, popüler API'ler bu tür sınırlamaları kullanır:

• Twitter API: standart erişim için 15 dakikada 300 istek
• Instagram Graph API: uygulama başına saatte 200 istek
• Google Maps API: tarifeye bağlı, genellikle günde 100-1000 istek
• Wildberries API: bir IP'den dakikada yaklaşık 60 istek için resmi olmayan limitler
• Avito API: ilanları parse etmek için saniyede 10 istek

Rate limiting'in uygulandığı istek kaynaklarını belirlemenin birkaç yöntemi vardır:

Limit aşıldığında, API HTTP durumu 429 "Too Many Requests" döner ve limit sıfırlanma süresini belirten Retry-After başlığını gönderir. Bazı servisler "kaydırmalı pencere" (rolling window) kullanır, burada limit kademeli olarak güncellenir, diğerleri ise belirli bir zamanda sıfırlanan sabit bir pencere kullanır.

Neden proxy'ler otomatik olarak rate limiting'den kurtaramaz

Birçok geliştirici, sadece proxy bağlamanın yeterli olduğunu ve sınırsız sayıda istek gönderebileceğini yanlış bir şekilde düşünmektedir. Pratikte şu sorunlar ortaya çıkmaktadır:

Tüm istekler için tek bir proxy kullanımı

Eğer scriptiniz tüm istekler için aynı proxy IP adresini kullanıyorsa, API bunu normal bir kullanıcı olarak görür ve standart limitleri uygular. Örneğin, Wildberries üzerinden bir konum parser'ı ayarladınız ve tek bir konut proxy ile çalışıyorsunuz. Parser dakikada 100 istek yapıyor ama limit 60 istektir. Sonuç: IP'nin 10-30 dakika boyunca engellenmesi.

Yavaş IP döngüsü

Bazıları 5-10 proxy'den oluşan bir havuz kullanır ve bunlar arasında sırayla geçiş yapar. Sorun, her IP'nin yine de tam döngü gerçekleşmeden daha hızlı bir şekilde limite ulaşmasıdır. Diyelim ki 10 proxy'niz var ve IP başına limit 100 istek. Eğer saatte 1000 istek yapıyorsanız, her proxy 100 istek alır - tam limitin sınırında. Herhangi bir dengesiz dağılım engellemelere yol açacaktır.

Diğer kimlik belirleme faktörlerinin göz ardı edilmesi

IP döngüsü mükemmel olsa bile, engellenebilirsiniz, eğer:

• Tüm istekler aynı User-Agent ile geliyorsa (örneğin, python-requests/2.28.0)
• Tüm istekler için tek bir API anahtarı kullanılıyorsa
• İstekler mükemmel bir periyodiklikle geliyorsa (her 0.5 saniyede bir) - bu bir bot gibi görünür
• Proxy IP'leri aynı alt ağda bulunuyorsa (örneğin, hepsi 192.168.1.x aralığında)

IP adreslerinin itibarı

Veri merkezi proxy'leri genellikle kara listeye alınır çünkü IP'leri, parsing için yüzlerce diğer kullanıcı tarafından kullanılır. API, bu tür adreslere daha katı limitler uygulayabilir veya hemen engelleyebilir. Örneğin, Instagram ve Facebook, veri merkezlerini agresif bir şekilde yasaklar, resmi limitleri aşmasanız bile.

Limitleri aşmak için IP döngüsü stratejileri

Doğru proxy döngüsü, rate limiting'i aşmanın anahtarıdır. Görevine bağlı olarak etkili stratejileri inceleyelim.

Her istekte döngü

En agresif strateji: her istek yeni bir IP üzerinden geçer. Çok katı limitler (IP başına 1-5 istek) veya yükü en fazla yaymak gerektiğinde uygundur. Bunun için rezidans proxy'leri otomatik döngü ile kullanılır - milyonlarca IP sunar ve her istek otomatik olarak yeni bir adres alır.

Kullanım örneği: Instagram'ı resmi olmayan API üzerinden parse etmek, burada limit IP başına dakikada 5 istektir. Her istekte döngü ile 300 farklı IP üzerinden dakikada 300 istek yapabilirsiniz.

Zamana göre döngü (sticky sessions)

IP adresi belirli bir süre (5-30 dakika) kullanılır, ardından yeni bir IP ile değiştirilir. Bu strateji, oturumun korunmasını gerektiren API'ler için uygundur veya bir "kullanıcıdan" birkaç ilişkili istek yapmanız gerektiğinde.

Optimum döngü süresinin hesaplanması: eğer API limiti saatte 100 istek ise ve bir IP üzerinden 50 istek yapmayı planlıyorsanız, 30 dakikalık sticky session kullanın. Bu süre içinde 25 istek yaparsınız (eşit yük altında), bu da limitin iki katıdır.

Limitleri izleyerek havuzdan döngü

Gelişmiş bir strateji: scriptiniz her IP'den gelen istek sayısını takip eder ve limite yaklaşırken otomatik olarak yeni bir IP'ye geçer. Örneğin, 20 proxy'den oluşan bir havuzunuz var, API limiti saatte 100 istek. Script, her IP için sayacı izler ve 90 isteğe ulaştığında bir sonraki IP'ye geçer.

Bu strateji, mantık programlaması gerektirir ama maksimum verimlilik sağlar: her proxy'yi tam kapasitede kullanırsınız, limitleri aşmadan.

Coğrafi döngü

Bazı API'ler, bölgeye bağlı olarak farklı limitler uygular. Örneğin, bir servis ABD'den gelen istekleri Avrupa'dan gelenlerden daha katı bir şekilde sınırlayabilir. Bu tür durumlarda, farklı ülkelerden proxy'ler kullanın ve yükü bunlar arasında dağıtın.

İstekler arasındaki gecikme ayarları

Mükemmel bir IP döngüsü ile bile, istekler arasındaki gecikmeleri doğru bir şekilde ayarlamak önemlidir. Çok hızlı istekler saldırı gibi görünür, hatta farklı IP'lerden gelse bile.

Minimum gecikmenin hesaplanması

Formül: gecikme = (zaman penceresi saniye cinsinden / istek limiti) × güvenlik katsayısı

Örnek: API saatte 100 istek izni veriyor (3600 saniye). Minimum gecikme = 3600 / 100 = 36 saniye. Güvenlik katsayısı 1.2 ekliyoruz: 36 × 1.2 = 43 saniye bir IP'den gelen istekler arasında.

Eğer 10 proxy kullanıyorsanız ve döngü yapıyorsanız, her 4.3 saniyede bir istek yapabilirsiniz (43 / 10), hiçbir IP'de limiti aşmadan.

Rastgele gecikmeler (jitter)

5 saniyelik sabit bir gecikme yerine, 3 ile 7 saniye arasında rastgele aralıklar kullanın. Bu, trafiğinizi gerçek bir kullanıcının davranışına benzetir. Birçok bot koruma sistemi, kalıpları analiz eder: eğer istekler tam olarak her 5.0 saniyede geliyorsa, bu şüpheli görünür.

Hatalarda üssel gecikme

429 hatası aldığınızda, hemen istek göndermeye devam etmeyin. Üssel gecikme kullanın: ilk deneme 1 saniye sonra, ikinci 2 saniye sonra, üçüncü 4 saniye sonra, dördüncü 8 saniye sonra ve devam edin. Bu, API'lerin müşterilerden beklediği standart bir uygulamadır.

API ile çalışmak için hangi proxy türünü seçmelisiniz

Proxy türünün seçimi, rate limiting'i aşma başarısını kritik şekilde etkiler. API ile çalışmak için her seçeneğin artılarını ve eksilerini inceleyelim.

Rezidans proxy'leri

Rezidans proxy'leri, internet sağlayıcıları tarafından tahsis edilen gerçek kullanıcıların IP adreslerini kullanır. API için bu, normal bir ev interneti gibi görünür.

Ne zaman kullanılmalı: Instagram, Facebook, TikTok parsing, pazar yerleri API'leri (Wildberries, Ozon) ile çalışma, IP itibarının kritik olduğu her görev.

Mobil proxy'ler

Mobil proxy'ler, mobil operatörlerin (4G/5G) IP'lerini kullanır. Tek bir IP, genellikle binlerce gerçek kullanıcı tarafından aynı anda kullanılır, bu nedenle API'ler bunları nadiren yasaklar.

Ne zaman kullanılmalı: mobil API'lerle çalışma, Instagram/TikTok'u büyük hacimlerde parse etme, yasaklardan maksimum koruma gerektiğinde.

Veri merkezi proxy'leri

Veri merkezi proxy'leri, veri merkezlerinde barındırılan sunucuların IP adresleridir. Gerçek kullanıcılarla bağlantılı değildirler.

Ne zaman kullanılmalı: katı koruma gerektirmeyen kamu API'lerini parse etme (hava durumu, döviz kurları, haberler), kendi API'lerinizle çalışma, test etme ve geliştirme.

Pratik uygulama: Python'da kod örnekleri

Proxy kullanarak rate limiting'i aşmanın somut örneklerini inceleyelim. Tüm örnekler requests kütüphanesi ile Python'dadır.

Proxy havuzundan basit döngü

Liste üzerinden döngüsel IP ile temel bir uygulama:

import requests
import time
from itertools import cycle

# Proxy listesi (format: protocol://user:pass@host:port)
PROXY_LIST = [
    'http://user1:pass1@proxy1.example.com:8080',
    'http://user2:pass2@proxy2.example.com:8080',
    'http://user3:pass3@proxy3.example.com:8080',
]

# Döngüsel bir iterator oluştur
proxy_pool = cycle(PROXY_LIST)

def make_request(url):
    proxy = next(proxy_pool)  # Havuzdan bir sonraki proxy'yi al
    proxies = {
        'http': proxy,
        'https': proxy
    }
    
    try:
        response = requests.get(url, proxies=proxies, timeout=10)
        return response
    except requests.exceptions.RequestException as e:
        print(f"Proxy {proxy} ile hata: {e}")
        return None

# Kullanım örneği
for i in range(10):
    response = make_request('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"İstek {i+1}: başarı")
    time.sleep(2)  # İstekler arasındaki gecikme

Limitleri izleyerek döngü

Her proxy için istekleri sayan ve limite yaklaşırken geçiş yapan daha gelişmiş bir versiyon:

import requests
import time
from collections import defaultdict

class ProxyRotator:
    def __init__(self, proxy_list, max_requests_per_ip=90, time_window=3600):
        self.proxy_list = proxy_list
        self.max_requests = max_requests_per_ip  # IP başına istek limiti
        self.time_window = time_window  # Zaman penceresi saniye cinsinden
        self.request_counts = defaultdict(list)  # Her IP için istek geçmişi
        self.current_index = 0
    
    def get_proxy(self):
        """En az istek olan proxy'yi döndürür"""
        current_time = time.time()
        
        # Zaman penceresinin dışındaki eski kayıtları temizle
        for proxy in self.request_counts:
            self.request_counts[proxy] = [
                t for t in self.request_counts[proxy]
                if current_time - t < self.time_window
            ]
        
        # En az istek olan proxy'yi bul
        available_proxies = []
        for proxy in self.proxy_list:
            count = len(self.request_counts[proxy])
            if count < self.max_requests:
                available_proxies.append((proxy, count))
        
        if not available_proxies:
            # Eğer tüm proxy'ler limitlerini doldurduysa, bekle
            oldest_request = min(
                min(times) for times in self.request_counts.values() if times
            )
            wait_time = self.time_window - (current_time - oldest_request) + 1
            print(f"Tüm proxy'ler limitlerini doldurdu. {wait_time:.0f} saniye bekliyoruz...")
            time.sleep(wait_time)
            return self.get_proxy()
        
        # En az istek olan proxy'yi seç
        proxy = min(available_proxies, key=lambda x: x[1])[0]
        self.request_counts[proxy].append(current_time)
        return proxy
    
    def make_request(self, url, **kwargs):
        proxy = self.get_proxy()
        proxies = {'http': proxy, 'https': proxy}
        
        try:
            response = requests.get(url, proxies=proxies, timeout=10, **kwargs)
            return response
        except requests.exceptions.RequestException as e:
            print(f"Proxy {proxy} ile hata: {e}")
            return None

# Kullanım örneği
PROXY_LIST = [
    'http://user:pass@proxy1.example.com:8080',
    'http://user:pass@proxy2.example.com:8080',
]

rotator = ProxyRotator(PROXY_LIST, max_requests_per_ip=100, time_window=3600)

for i in range(500):  # 500 istek yap
    response = rotator.make_request('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"İstek {i+1}: başarı")
    time.sleep(1)  # Minimum gecikme

429 hatalarını üssel gecikme ile işleme

"Too Many Requests" yanıtını doğru bir şekilde işlemek için Retry-After başlığını dikkate alın:

import requests
import time

def make_request_with_retry(url, proxies, max_retries=5):
    """429 hatası durumunda otomatik tekrar ile istek yapar"""
    
    for attempt in range(max_retries):
        try:
            response = requests.get(url, proxies=proxies, timeout=10)
            
            if response.status_code == 200:
                return response
            
            elif response.status_code == 429:
                # Retry-After başlığını kontrol et
                retry_after = response.headers.get('Retry-After')
                
                if retry_after:
                    wait_time = int(retry_after)
                    print(f"Rate limit. {wait_time} saniye bekliyoruz (Retry-After'dan)")
                else:
                    # Üssel gecikme: 2^attempt saniye
                    wait_time = 2 ** attempt
                    print(f"Rate limit. Deneme {attempt+1}, {wait_time} saniye bekliyoruz")
                
                time.sleep(wait_time)
                continue
            
            else:
                print(f"HTTP hatası {response.status_code}")
                return None
        
        except requests.exceptions.RequestException as e:
            print(f"Bağlantı hatası: {e}")
            if attempt < max_retries - 1:
                time.sleep(2 ** attempt)
                continue
            return None
    
    print(f"Deneme sayısı aşıldı ({max_retries})")
    return None

# Kullanım örneği
proxies = {
    'http': 'http://user:pass@proxy.example.com:8080',
    'https': 'http://user:pass@proxy.example.com:8080'
}

response = make_request_with_retry('https://api.example.com/data', proxies)
if response:
    print("Veriler alındı:", response.json())

Otomatik döngü ile rezidans proxy kullanımı

Birçok rezidans proxy sağlayıcısı, her istekte otomatik olarak IP'yi değiştiren bir endpoint sunar. Ayar örneği:

import requests
import random
import time

# Otomatik döngü ile rezidans proxy
# Format: protocol://username:password@gateway:port
ROTATING_PROXY = 'http://customer-USER:PASS@proxy.provider.com:12321'

def make_request_rotating(url):
    """Her seferinde yeni IP ile dönen proxy üzerinden istek yapar"""
    proxies = {
        'http': ROTATING_PROXY,
        'https': ROTATING_PROXY
    }
    
    # Daha fazla anonimlik için rastgele User-Agent ekleyin
    user_agents = [
        'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
        'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
        'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36',
    ]
    
    headers = {
        'User-Agent': random.choice(user_agents)
    }
    
    try:
        response = requests.get(url, proxies=proxies, headers=headers, timeout=15)
        return response
    except requests.exceptions.RequestException as e:
        print(f"Hata: {e}")
        return None

# 100 istek yapıyoruz, her seferinde farklı IP üzerinden
for i in range(100):
    response = make_request_rotating('https://api.example.com/data')
    if response and response.status_code == 200:
        print(f"İstek {i+1}: başarı, IP değiştirildi")
    
    # 1-3 saniye arasında rastgele gecikme
    time.sleep(random.uniform(1, 3))

Limitlerin izlenmesi ve hata yönetimi

API ile etkili bir şekilde çalışmak, limitlerin sürekli izlenmesini ve hataların doğru bir şekilde yönetilmesini gerektirir. İşte anahtar uygulamalar:

Yanıt başlıklarının analizi

Birçok API, yanıt başlıklarında limitler hakkında bilgi döner. Standart başlıklar:

• X-RateLimit-Limit — zaman penceresindeki maksimum istek sayısı
• X-RateLimit-Remaining — kalan istek sayısı
• X-RateLimit-Reset — limitin sıfırlanma zamanı (Unix zaman damgası)
• Retry-After — ne kadar süre sonra isteği tekrar gönderebileceğiniz

Bu başlıkları okuma örneği:

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

# Limit başlıklarını kontrol et
limit = response.headers.get('X-RateLimit-Limit')
remaining = response.headers.get('X-RateLimit-Remaining')
reset_time = response.headers.get('X-RateLimit-Reset')

if remaining:
    remaining = int(remaining)
    if remaining < 10:
        print(f"Dikkat! Sadece {remaining} istek kaldı")
        
if reset_time:
    import datetime
    reset_dt = datetime.datetime.fromtimestamp(int(reset_time))
    print(f"Limit {reset_dt'de sıfırlanacak")

Loglama ve istatistik

Her proxy için isteklerin ayrıntılı istatistiklerini tutun. Bu, sorunlu IP'leri belirlemenize ve döngüyü optimize etmenize yardımcı olacaktır:

import json
from datetime import datetime

class RequestLogger:
    def __init__(self):
        self.stats = {}
    
    def log_request(self, proxy, status_code, response_time):
        if proxy not in self.stats:
            self.stats[proxy] = {
                'total': 0,
                'success': 0,
                'rate_limited': 0,
                'errors': 0,
                'avg_response_time': 0
            }
        
        self.stats[proxy]['total'] += 1
        
        if status_code == 200:
            self.stats[proxy]['success'] += 1
        elif status_code == 429:
            self.stats[proxy]['rate_limited'] += 1
        else:
            self.stats[proxy]['errors'] += 1
        
        # Ortalama yanıt süresini güncelle
        current_avg = self.stats[proxy]['avg_response_time']
        total = self.stats[proxy]['total']
        self.stats[proxy]['avg_response_time'] = (
            (current_avg * (total - 1) + response_time) / total
        )
    
    def print_stats(self):
        print("\n=== Proxy İstatistikleri ===")
        for proxy, data in self.stats.items():
            success_rate = (data['success'] / data['total'] * 100) if data['total'] > 0 else 0
            print(f"\nProxy: {proxy}")
            print(f"  Toplam istek: {data['total']}")
            print(f"  Başarılı: {data['success']} ({success_rate:.1f}%)")
            print(f"  Rate limited: {data['rate_limited']}")
            print(f"  Hatalar: {data['errors']}")
            print(f"  Ortalama yanıt süresi: {data['avg_response_time']:.2f}s")

# Kullanım
logger = RequestLogger()

start_time = time.time()
response = requests.get(url, proxies=proxies)
response_time = time.time() - start_time

logger.log_request(proxy, response.status_code, response_time)
logger.print_stats()

Stratejinin otomatik geçişi

Eğer sürekli 429 hatası alıyorsanız, otomatik olarak isteklerinizi yavaşlatın veya proxy havuzunuzu artırın:

class AdaptiveRateLimiter:
    def __init__(self, initial_delay=1.0):
        self.delay = initial_delay
        self.consecutive_429 = 0
    
    def on_success(self):
        """Başarılı istek - biraz hızlanabiliriz"""
        self.consecutive_429 = 0
        self.delay = max(0.5, self.delay * 0.95)  # Gecikmeyi %5 azalt
        
    def on_rate_limit(self):
        """429 aldık - yavaşlamalıyız"""
        self.consecutive_429 += 1
        self.delay *= 1.5  # Gecikmeyi 1.5 kat artır
        
        if self.consecutive_429 > 5:
            print("DİKKAT: Çok fazla 429 hatası. Ayarları kontrol edin!")
    
    def wait(self):
        """Sonraki isteği bekleme süresi"""
        time.sleep(self.delay)
        return self.delay

# Kullanım
limiter = AdaptiveRateLimiter(initial_delay=2.0)

for i in range(1000):
    response = make_request(url)
    
    if response.status_code == 200:
        limiter.on_success()
    elif response.status_code == 429:
        limiter.on_rate_limit()
    
    delay = limiter.wait()
    print(f"İstek {i+1}, gecikme: {delay:.2f}s")

Captcha ve diğer engellemelerin işlenmesi

Bazı API'ler limitleri aştığınızda doğrudan engelleme yerine captcha gösterir. Belirtiler:

• 403 durum kodu ve yanıt gövdesinde "captcha" veya "recaptcha" içeren bir metin
• Captcha sayfasına yönlendirme (durum 302)
• X-Captcha-Required: true gibi özel başlıklar

Bu tür durumlarda şunları yapmalısınız:

1. Bu IP'yi hemen kullanmayı durdurun
2. Havuzdan başka bir proxy'ye geçin
3. İstekler arasındaki gecikmeleri artırın
4. User-Agent ve diğer başlıklarda daha fazla çeşitlilik ekleyin

Sonuç

Proxy kullanarak API rate limiting'i aşmak, sadece teknik bir ayar değil, doğru proxy türünün seçilmesi, IP döngüsü ayarları, gecikme yönetimi ve limitlerin izlenmesini içeren kapsamlı bir stratejidir. Yazıdan çıkarılacak ana noktalar:

• Proxy'ler, rate limiting sorununu tek başına çözmez - doğru döngü stratejisi gereklidir
• Sosyal medya ve katı API'ler için rezidans veya mobil proxy kullanın, kamu API'leri için veri merkezleri uygundur
• Proxy havuzunun boyutunu API limitleri ve istek hızınıza göre hesaplayın
• Her zaman doğru gecikmeleri ayarlayın ve limitleri izleyin