API Üzerinden Proxy Değiştirme Otomasyonu: Veri Çekme ve Arbitraj için Rotasyon Nasıl Ayarlanır

Yüzlerce istekle çalışırken manuel proxy değiştirme zaman ve para kaybıdır. API rotasyonu, engellemelerde IP adreslerini otomatik olarak değiştirmeye, yükü dağıtmaya ve scraping veya çoklu hesap yönetimini ölçeklendirmeye olanak tanır. Bu kılavuzda, marketplace scraping'den Facebook Ads hesap farming'e kadar farklı görevler için otomatik proxy değiştirmeyi nasıl yapılandıracağınızı inceleyeceğiz.

Materyal hem Python veya Node.js ile scraper yazan geliştiriciler hem de API entegrasyonlu hazır araçlar kullanan arbitrajcılar için uygundur.

API Üzerinden Proxy Değiştirme Otomasyonu Neden Gerekli

API üzerinden otomatik IP adresi rotasyonu, farklı alanlardaki uzmanların karşılaştığı birkaç kritik sorunu çözer:

Manuel değiştirmeye kıyasla API otomasyonunun temel avantajları:

• Hız: IP değişimi milisaniyeler içinde programatik olarak, insan müdahalesi olmadan gerçekleşir
• Ölçeklenebilirlik: Tek bir arayüz üzerinden aynı anda binlerce proxy yönetilebilir
• Hata toleransı: Çalışmayan proxy'lerin süreci durdurmadan otomatik değiştirilmesi
• Esneklik: Belirli görev için rotasyon kurallarının yapılandırılması: zamana, istek sayısına, coğrafyaya göre
• Tasarruf: Yük dengeleme yoluyla trafiğin optimal kullanımı

Tipik kullanım senaryosu: Wildberries'de rakip fiyatlarını scraping yapıyorsunuz. API olmadan engelleri manuel olarak izlemeniz, proxy sağlayıcı paneline girmeniz, yeni verileri kopyalamanız, bunları script'e yapıştırmanız gerekir. API ile tüm bunlar otomatik olur: script 429 hatası (Too Many Requests) alır, proxy servis API'sine istek gönderir, yeni IP alır ve çalışmaya devam eder.

Proxy Rotasyon Türleri: Sticky Sessions vs Otomatik Değiştirme

Otomasyonu yapılandırmadan önce, IP adresi rotasyon türleri arasındaki farkı anlamak önemlidir. Strateji seçimi görevinize bağlıdır.

Sticky Sessions (oturum proxy'leri)

Sticky sessions kullanıldığında, bir IP adresi belirli bir süre (genellikle 5 ila 30 dakika) oturumunuza sabitlenir. Değişim yalnızca oturum süresi dolduktan veya API isteğinizle gerçekleşir.

Ne zaman kullanılır:

• Sosyal medya hesaplarıyla çalışma (Instagram, Facebook) — sık IP değişimi şüphe uyandırır
• Oturumu korumak gereken çok sayfalı formları doldurma
• Oturum boyunca belirli bir bölgeden reklam testi
• IP değişiminin oturumu kapatacağı kimlik doğrulamalı siteleri scraping

Sticky session oluşturmak için API isteği örneği (genellikle özel login formatı kullanılır):

// Format: username-session-SESSIONID:password
// SESSIONID — herhangi bir string, aynı = bir IP

proxy = "username-session-abc123:password@gate.proxycove.com:8000"

// session-abc123 ile tüm istekler oturum süresince bir IP alır
// Yeni IP için farklı SESSIONID kullanın: session-xyz789

Her istekte otomatik rotasyon

IP adresi proxy sunucusuna her yeni bağlantıda değişir. Bu, oturum parametreleri belirtilmeden residential proxy'lerin standart davranışıdır.

Ne zaman kullanılır:

• Kimlik doğrulama olmadan toplu scraping (fiyatlar, kişiler, ilanlar)
• Genel API'lerde agresif rate limit'leri aşma
• 10-20 istekten sonra IP'yi yasaklayan sitelerden veri toplama
• Farklı bölgelerden içerik erişilebilirliğini kontrol etme

Python'da kullanım örneği (her istek = yeni IP):

import requests

proxy = {
    "http": "http://username:password@gate.proxycove.com:8000",
    "https": "http://username:password@gate.proxycove.com:8000"
}

# Her istek yeni IP alır
for i in range(10):
    response = requests.get("https://api.ipify.org", proxies=proxy)
    print(f"İstek {i+1}, IP: {response.text}")

Zamanlayıcıyla rotasyon

IP'yi ne zaman değiştireceğinizi programatik olarak kontrol edersiniz: her N dakikada, M istekten sonra veya belirli hatalar alındığında. Bu, proxy servis API'si üzerinden uygulanan hibrit bir yaklaşımdır.

Ne zaman kullanılır:

• Trafik kullanımı optimizasyonu — yalnızca gerektiğinde değiştirme
• Kalıpları izleyen sitelerle çalışma (çok sık değişim = ban)
• Anonimlik ve oturum kararlılığı arasında denge

Proxy Servis API'leriyle Çalışmanın Temelleri

Modern proxy sağlayıcılarının çoğu iki yönetim yöntemi sunar: web paneli ve API üzerinden. API, fonksiyonlara programatik erişim sağlar: proxy listesi alma, yeni oturumlar oluşturma, bakiye kontrolü, kullanım istatistikleri.

Tipik proxy servis API metodları

Her sağlayıcının kendi dokümantasyonu olsa da, standart metodlar genellikle şunları içerir:

• GET /api/v1/proxy/list — ülke, tür filtrelemesiyle mevcut proxy listesini alma
• POST /api/v1/proxy/rotate — aktif oturumda IP'yi zorla değiştirme
• GET /api/v1/account/balance — bakiyedeki trafik veya para miktarını kontrol etme
• GET /api/v1/stats — kullanım istatistikleri: trafik hacmi, istek sayısı, hatalar
• POST /api/v1/session/create — parametrelerle yeni sticky session oluşturma (ülke, şehir, süre)

Kimlik doğrulama genellikle istek başlığındaki API anahtarı üzerinden yapılır:

curl -X GET "https://api.provider.com/v1/proxy/list?country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

Yanıt genellikle JSON formatında gelir:

{
  "status": "success",
  "data": {
    "proxies": [
      {
        "ip": "123.45.67.89",
        "port": 8000,
        "country": "US",
        "city": "New York",
        "protocol": "http",
        "username": "user123",
        "password": "pass456"
      }
    ],
    "total": 150,
    "available": 147
  }
}

API üzerinden oturum yönetimi

IP yaşam süresi kontrolü gerektiren görevler için (çoklu hesap, hesaplarla çalışma), API üzerinden adlandırılmış oturumlar oluşturulur. Bu, onlarca ve yüzlerce izole IP adresini programatik olarak yönetmeye olanak tanır.

Parametrelerle oturum oluşturma örneği:

POST /api/v1/session/create
{
  "country": "US",
  "state": "California",
  "session_duration": 600,  // 10 dakika
  "session_id": "facebook_account_001"
}

// Yanıt:
{
  "status": "success",
  "session": {
    "id": "facebook_account_001",
    "proxy": "gate.provider.com:8000",
    "username": "user-session-facebook_account_001",
    "password": "your_password",
    "ip": "45.67.89.123",
    "expires_at": "2024-01-15T15:30:00Z"
  }
}

Artık bu proxy'yi script'inizde veya antidetect tarayıcınızda kullanabilirsiniz ve IP 10 dakika boyunca değişmeden kalacaktır. Oturumu uzatmak için aynı session_id ile tekrar istek gönderilir.

Python'da Otomasyon Örnekleri: requests, Selenium, Scrapy

Python, scraping ve otomasyon için en popüler dildir. Ana araçlarla API proxy rotasyonu entegrasyonu örneklerini inceleyelim.

requests'te otomatik proxy değiştirme

requests kütüphanesi basit HTTP istekleri için kullanılır. Otomatik rotasyon için hatalarda proxy'yi değiştiren bir wrapper sınıfı oluşturalım:

import requests
import random
import time

class RotatingProxySession:
    def __init__(self, proxy_list):
        """
        proxy_list: proxy verileriyle sözlük listesi
        [{"http": "http://user:pass@ip:port", "https": "..."}]
        """
        self.proxy_list = proxy_list
        self.current_proxy = None
        self.session = requests.Session()
        self.rotate()
    
    def rotate(self):
        """Listeden rastgele proxy seç"""
        self.current_proxy = random.choice(self.proxy_list)
        self.session.proxies.update(self.current_proxy)
        print(f"Proxy'ye geçildi: {self.current_proxy['http']}")
    
    def get(self, url, max_retries=3, **kwargs):
        """Hatalarda otomatik rotasyonla GET isteği"""
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, timeout=10, **kwargs)
                
                # Engelleme alındıysa — proxy değiştir
                if response.status_code in [403, 429, 503]:
                    print(f"{response.status_code} alındı, proxy değiştiriliyor...")
                    self.rotate()
                    time.sleep(2)
                    continue
                
                return response
                
            except requests.exceptions.ProxyError:
                print(f"Proxy çalışmıyor, deneme {attempt+1}/{max_retries}")
                self.rotate()
                time.sleep(2)
            
            except requests.exceptions.Timeout:
                print("Timeout, proxy değiştiriliyor...")
                self.rotate()
                time.sleep(2)
        
        raise Exception(f"{max_retries} denemeden sonra istek yapılamadı")

# Kullanım:
proxies = [
    {"http": "http://user1:pass@gate1.com:8000", "https": "http://user1:pass@gate1.com:8000"},
    {"http": "http://user2:pass@gate2.com:8000", "https": "http://user2:pass@gate2.com:8000"},
]

session = RotatingProxySession(proxies)

# Wildberries scraping
for page in range(1, 50):
    url = f"https://www.wildberries.ru/catalog/page={page}"
    response = session.get(url)
    print(f"Sayfa {page}: {response.status_code}")

Tarayıcı otomasyonu için Selenium entegrasyonu

Selenium, JavaScript'li siteleri scraping ve tarayıcıda işlemleri otomatikleştirmek için kullanılır. Proxy değiştirmek için driver'ı yeniden oluşturmak gerekir, çünkü proxy ayarları başlatmada yapılır:

from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import time

class SeleniumRotatingProxy:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.driver = None
        self.current_proxy_index = 0
    
    def create_driver(self):
        """Mevcut proxy ile yeni driver oluştur"""
        if self.driver:
            self.driver.quit()
        
        proxy = self.proxy_list[self.current_proxy_index]
        
        chrome_options = Options()
        chrome_options.add_argument(f'--proxy-server={proxy}')
        chrome_options.add_argument('--headless')  # GUI olmadan
        
        self.driver = webdriver.Chrome(options=chrome_options)
        print(f"Proxy ile driver oluşturuldu: {proxy}")
    
    def rotate(self):
        """Sonraki proxy'ye geç"""
        self.current_proxy_index = (self.current_proxy_index + 1) % len(self.proxy_list)
        self.create_driver()
    
    def get_with_retry(self, url, max_retries=3):
        """Hatalarda otomatik proxy değiştirmeyle URL aç"""
        for attempt in range(max_retries):
            try:
                if not self.driver:
                    self.create_driver()
                
                self.driver.get(url)
                
                # Engelleme kontrolü (örneğin captcha arama)
                if "captcha" in self.driver.page_source.lower():
                    print("Captcha tespit edildi, proxy değiştiriliyor...")
                    self.rotate()
                    time.sleep(3)
                    continue
                
                return self.driver.page_source
                
            except Exception as e:
                print(f"Hata: {e}, proxy değiştiriliyor (deneme {attempt+1})")
                self.rotate()
                time.sleep(3)
        
        raise Exception("Sayfa yüklenemedi")

# Kullanım:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
]

bot = SeleniumRotatingProxy(proxies)

# Ozon scraping
for i in range(10):
    html = bot.get_with_retry(f"https://www.ozon.ru/category/page-{i}")
    print(f"Sayfa {i} HTML'i alındı, uzunluk: {len(html)}")

bot.driver.quit()

Proxy rotasyonu için Scrapy middleware

Scrapy — büyük ölçekli scraping için framework. Proxy rotasyonu, tüm isteklere otomatik olarak uygulanan middleware üzerinden gerçekleştirilir:

# middlewares.py

import random
from scrapy.exceptions import IgnoreRequest

class RotatingProxyMiddleware:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
    
    @classmethod
    def from_crawler(cls, crawler):
        # Ayarlardan proxy listesini al
        proxy_list = crawler.settings.getlist('ROTATING_PROXY_LIST')
        return cls(proxy_list)
    
    def process_request(self, request, spider):
        # Her isteğe rastgele proxy ata
        proxy = random.choice(self.proxy_list)
        request.meta['proxy'] = proxy
        spider.logger.info(f'Proxy kullanılıyor: {proxy}')
    
    def process_exception(self, request, exception, spider):
        # Proxy hatasında — başkasıyla tekrarla
        proxy = random.choice(self.proxy_list)
        spider.logger.warning(f'Proxy hatası, geçiliyor: {proxy}')
        request.meta['proxy'] = proxy
        return request  # isteği tekrarla

# settings.py

DOWNLOADER_MIDDLEWARES = {
    'myproject.middlewares.RotatingProxyMiddleware': 350,
}

ROTATING_PROXY_LIST = [
    'http://user:pass@gate1.com:8000',
    'http://user:pass@gate2.com:8000',
    'http://user:pass@gate3.com:8000',
]

# Hatalarda istekleri tekrarla
RETRY_TIMES = 5
RETRY_HTTP_CODES = [403, 429, 500, 502, 503]

Artık her Scrapy isteği otomatik olarak listeden rastgele proxy alacak ve hatalarda farklı IP ile tekrarlanacaktır.

Node.js'de Otomasyon: axios, Puppeteer, Playwright

Node.js, asenkronluk ve tarayıcı araçlarıyla iyi entegrasyon sayesinde scraper ve bot oluşturmak için popülerdir. Ana kütüphanelerde proxy rotasyonu örneklerini inceleyelim.

Otomatik rotasyonla Axios

Axios — HTTP istekleri için kütüphane. Proxy havuzu ve hatalarda otomatik değiştirme ile bir sınıf oluşturalım:

const axios = require('axios');
const HttpsProxyAgent = require('https-proxy-agent');

class RotatingProxyClient {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
  }

  getProxy() {
    const proxy = this.proxyList[this.currentIndex];
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
    return proxy;
  }

  async request(url, options = {}, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      const proxy = this.getProxy();
      const agent = new HttpsProxyAgent(proxy);

      try {
        const response = await axios.get(url, {
          ...options,
          httpsAgent: agent,
          timeout: 10000
        });

        // Engelleme alındıysa — sonraki deneme
        if ([403, 429, 503].includes(response.status)) {
          console.log(`Durum ${response.status}, proxy değiştiriliyor...`);
          continue;
        }

        return response.data;

      } catch (error) {
        console.log(`Proxy ${proxy} ile hata: ${error.message}`);
        if (i === maxRetries - 1) throw error;
      }
    }
  }
}

// Kullanım:
const proxies = [
  'http://user:pass@gate1.com:8000',
  'http://user:pass@gate2.com:8000',
];

const client = new RotatingProxyClient(proxies);

(async () => {
  for (let page = 1; page <= 20; page++) {
    const data = await client.request(`https://api.example.com/products?page=${page}`);
    console.log(`Sayfa ${page}: ${data.length} ürün alındı`);
  }
})();

Proxy rotasyonuyla Puppeteer

Puppeteer, Chrome tarayıcısını yönetir. Proxy tarayıcı başlatılırken ayarlandığı için değiştirmek için instance'ı yeniden oluşturmak gerekir:

const puppeteer = require('puppeteer');

class PuppeteerRotatingProxy {
  constructor(proxyList) {
    this.proxyList = proxyList;
    this.currentIndex = 0;
    this.browser = null;
  }

  async createBrowser() {
    if (this.browser) await this.browser.close();

    const proxy = this.proxyList[this.currentIndex];
    console.log(`Proxy ile tarayıcı başlatılıyor: ${proxy}`);

    this.browser = await puppeteer.launch({
      headless: true,
      args: [`--proxy-server=${proxy}`]
    });
  }

  rotate() {
    this.currentIndex = (this.currentIndex + 1) % this.proxyList.length;
  }

  async scrape(url, maxRetries = 3) {
    for (let i = 0; i < maxRetries; i++) {
      try {
        if (!this.browser) await this.createBrowser();

        const page = await this.browser.newPage();
        
        // Proxy kimlik doğrulama (gerekirse)
        await page.authenticate({
          username: 'your_username',
          password: 'your_password'
        });

        await page.goto(url, { waitUntil: 'networkidle2', timeout: 30000 });

        // Captcha kontrolü
        const content = await page.content();
        if (content.includes('captcha')) {
          console.log('Captcha tespit edildi, proxy değiştiriliyor...');
          this.rotate();
          await this.createBrowser();
          continue;
        }

        return content;

      } catch (error) {
        console.log(`Hata: ${error.message}, deneme ${i+1}`);
        this.rotate();
        await this.createBrowser();
      }
    }
    throw new Error('Sayfa yüklenemedi');
  }
}

// Kullanım:
const proxies = ['gate1.com:8000', 'gate2.com:8000'];
const scraper = new PuppeteerRotatingProxy(proxies);

(async () => {
  const html = await scraper.scrape('https://www.avito.ru/moskva');
  console.log(`HTML alındı, uzunluk: ${html.length}`);
  await scraper.browser.close();
})();

Rotasyon desteğiyle Playwright

Playwright — daha iyi performansla Puppeteer'a modern alternatif. Proxy yapılandırması benzerdir:

const { chromium } = require('playwright');

async function scrapeWithRotation(urls, proxyList) {
  let proxyIndex = 0;

  for (const url of urls) {
    const proxy = proxyList[proxyIndex];
    
    const browser = await chromium.launch({
      headless: true,
      proxy: {
        server: proxy,
        username: 'your_user',
        password: 'your_pass'
      }
    });

    const page = await browser.newPage();
    
    try {
      await page.goto(url, { timeout: 30000 });
      const title = await page.title();
      console.log(`${url} → ${title} (proxy: ${proxy})`);
    } catch (error) {
      console.log(`${url} hatası: ${error.message}`);
    }

    await browser.close();
    
    // Sonraki URL için sonraki proxy
    proxyIndex = (proxyIndex + 1) % proxyList.length;
  }
}

const urls = [
  'https://www.wildberries.ru',
  'https://www.ozon.ru',
  'https://www.avito.ru'
];

const proxies = [
  'http://gate1.com:8000',
  'http://gate2.com:8000'
];

scrapeWithRotation(urls, proxies);

Antidetect Tarayıcılarla API Entegrasyonu: Dolphin Anty, AdsPower

Çoklu hesap yönetimiyle çalışan arbitrajcılar ve SMM uzmanları için Dolphin Anty veya AdsPower'da her profile manuel proxy atama saatler alır. Bu tarayıcıların API'leri, profil oluşturmayı ve proxy bağlamayı otomatikleştirmeye olanak tanır.

API üzerinden Dolphin Anty otomasyonu

Dolphin Anty, profil oluşturma, proxy atama, tarayıcıları programatik olarak başlatma fonksiyonlarına erişim sağlayan yerel API (http://localhost:3001/v1.0 üzerinde) sunar.

Benzersiz proxy'lerle toplu profil oluşturma için Python script örneği:

import requests
import json

DOLPHIN_API = "http://localhost:3001/v1.0"
API_TOKEN = "your_dolphin_api_token"

# Sağlayıcınızdan proxy listesi (API'leri üzerinden alındı)
proxies = [
    {"host": "gate1.com", "port": 8000, "login": "user1", "password": "pass1"},
    {"host": "gate2.com", "port": 8000, "login": "user2", "password": "pass2"},
]

def create_profile_with_proxy(name, proxy):
    """Proxy bağlantılı Dolphin profili oluştur"""
    
    payload = {
        "name": name,
        "tags": ["Facebook Ads", "Auto-created"],
        "proxy": {
            "type": "http",  # veya socks5
            "host": proxy["host"],
            "port": proxy["port"],
            "login": proxy["login"],
            "password": proxy["password"]
        },
        "fingerprint": {
            "os": "win",
            "webRTC": {
                "mode": "altered",
                "fillBasedOnIp": True
            },
            "canvas": {
                "mode": "noise"
            }
        }
    }
    
    headers = {
        "Authorization": f"Bearer {API_TOKEN}",
        "Content-Type": "application/json"
    }
    
    response = requests.post(
        f"{DOLPHIN_API}/browser_profiles",
        headers=headers,
        data=json.dumps(payload)
    )
    
    if response.status_code == 200:
        profile = response.json()
        print(f"✓ Profil oluşturuldu: {name}, ID: {profile['id']}")
        return profile['id']
    else:
        print(f"✗ {name} oluşturma hatası: {response.text}")
        return None

# Proxy rotasyonuyla 50 profil oluştur
for i in range(50):
    proxy = proxies[i % len(proxies)]  # döngüsel rotasyon
    profile_name = f"FB_Account_{i+1:03d}"
    create_profile_with_proxy(profile_name, proxy)

Artık Dolphin Anty'de her biri benzersiz tarayıcı parmak izi ve proxy'ye sahip 50 profiliniz var. Profili programatik olarak başlatmak için:

def start_profile(profile_id):
    """Tarayıcı profilini başlat"""
    response = requests.get(
        f"{DOLPHIN_API}/browser_profiles/{profile_id}/start",
        headers={"Authorization": f"Bearer {API_TOKEN}"}
    )
    
    if response.status_code == 200:
        data = response.json()
        print(f"Profil başlatıldı, WebDriver portu: {data['automation']['port']}")
        return data['automation']['port']
    else:
        print(f"Başlatma hatası: {response.text}")

# Profili başlat ve Selenium ile yönet
port = start_profile("profile_id_here")

from selenium import webdriver
driver = webdriver.Remote(
    command_executor=f'http://127.0.0.1:{port}',
    options=webdriver.ChromeOptions()
)
driver.get("https://facebook.com")

AdsPower otomasyonu

AdsPower da yerel API sağlar. Mantık Dolphin'e benzer, ancak farklı endpoint'lerle:

import requests

ADSPOWER_API = "http://local.adspower.net:50325/api/v1"

def create_adspower_profile(name, proxy):
    payload = {
        "name": name,
        "group_id": "0",  # Profil grubu ID'si
        "domain_name": "facebook.com",
        "open_urls": ["https://facebook.com"],
        "repeat_config": ["0"],
        "username": proxy["login"],
        "password": proxy["password"],
        "proxy_type": "http",
        "proxy_host": proxy["host"],
        "proxy_port": proxy["port"],
        "proxy_user": proxy["login"],
        "proxy_password": proxy["password"]
    }
    
    response = requests.post(
        f"{ADSPOWER_API}/user/create",
        json=payload
    )
    
    if response.json()["code"] == 0:
        user_id = response.json()["data"]["id"]
        print(f"✓ AdsPower profili oluşturuldu: {name}, ID: {user_id}")
        return user_id
    else:
        print(f"✗ Hata: {response.json()['msg']}")

# Profil oluşturma
for i, proxy in enumerate(proxies):
    create_adspower_profile(f"TikTok_Account_{i+1}", proxy)

Bu tür otomasyon, onlarca hesapla çalışırken kritik öneme sahiptir. Her profile proxy verilerini manuel olarak kopyalamak yerine, script'i çalıştırır ve dakikalar içinde hazır altyapı elde edersiniz.

Hata Yönetimi ve Otomatik Fallback

Proxy'lerle çalışırken kaçınılmaz durumlar vardır: IP hedef site tarafından engellenmiş, proxy sunucusu yanıt vermiyor, trafik bitmiş. Doğru hata yönetimi — kararlı otomasyonun anahtarıdır.

Hata türleri ve yönetim stratejileri

Akıllı retry sistemi uygulaması

Basit istek tekrarı yerine, üstel gecikme ve çalışmayan proxy'lerin kara listesiyle bir sistem oluşturalım:

import requests
import time
from collections import defaultdict

class SmartProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.blacklist = set()  # Çalışmayan IP'ler
        self.error_count = defaultdict(int)  # IP başına hata sayacı
        self.max_errors = 3  # 3 hatadan sonra — kara listeye
    
    def get_working_proxy(self):
        """Kara listede olmayan proxy al"""
        available = [p for p in self.proxy_list if p not in self.blacklist]
        if not available:
            # Tüm proxy'ler banlı — kara listeyi temizle
            print("⚠ Tüm proxy'ler engellenmiş, kara liste sıfırlanıyor")
            self.blacklist.clear()
            self.error_count.clear()
            available = self.proxy_list
        return available[0]
    
    def mark_error(self, proxy):
        """Proxy hatasını işaretle"""
        self.error_count[proxy] += 1
        if self.error_count[proxy] >= self.max_errors:
            self.blacklist.add(proxy)
            print(f"✗ Proxy {proxy} kara listeye eklendi")
    
    def request_with_retry(self, url, max_retries=5):
        """Akıllı tekrarlarla istek"""
        for attempt in range(max_retries):
            proxy = self.get_working_proxy()
            
            try:
                # Üstel gecikme: 1s, 2s, 4s, 8s...
                if attempt > 0:
                    delay = 2 ** attempt
                    print(f"Deneme {attempt+1} öncesi {delay}s bekleniyor")
                    time.sleep(delay)
                
                response = requests.get(
                    url,
                    proxies={"http": proxy, "https": proxy},
                    timeout=15
                )
                
                # Başarı — hata sayacını sıfırla
                if response.status_code == 200:
                    self.error_count[proxy] = 0
                    return response
                
                # Engelleme — proxy değiştir
                elif response.status_code in [403, 429]:
                    print(f"Durum {response.status_code}, proxy değiştiriliyor")
                    self.mark_error(proxy)
                    continue
                
            except requests.exceptions.ProxyError:
                print(f"{proxy} ile ProxyError")
                self.mark_error(proxy)
                
            except requests.exceptions.Timeout:
                print(f"{proxy} ile Timeout")
                self.mark_error(proxy)
        
        raise Exception(f"{max_retries} denemeden sonra istek yapılamadı")

# Kullanım:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
    "http://user:pass@gate3.com:8000",
]

rotator = SmartProxyRotator(proxies)

for i in range(100):
    try:
        response = rotator.request_with_retry(f"https://api.example.com/data?page={i}")
        print(f"✓ Sayfa {i}: {len(response.text)} bayt")
    except Exception as e:
        print(f"✗ Sayfa {i}'de kritik hata: {e}")

İzleme ve uyarılar

Production sistemleri için proxy havuzunun sağlığını gerçek zamanlı izlemek önemlidir. Metrik loglama ekleyin:

import logging
from datetime import datetime

class ProxyMonitor:
    def __init__(self):
        self.stats = {
            "total_requests": 0,
            "successful": 0,
            "failed": 0,
            "proxy_errors": defaultdict(int),
            "start_time": datetime.now()
        }
        
        # Loglama yapılandırması
        logging.basicConfig(
            filename='proxy_rotation.log',
            level=logging.INFO,
            format='%(asctime)s - %(levelname)s - %(message)s'
        )
    
    def log_request(self, proxy, success, error=None):
        self.stats["total_requests"] += 1
        
        if success:
            self.stats["successful"] += 1
            logging.info(f"✓ {proxy} ile başarılı")
        else:
            self.stats["failed"] += 1
            self.stats["proxy_errors"][proxy] += 1
            logging.error(f"✗ {proxy} ile hata: {error}")
    
    def get_report(self):
        uptime = datetime.now() - self.stats["start_time"]
        success_rate = (self.stats["successful"] / self.stats["total_requests"] * 100) if self.stats["total_requests"] > 0 else 0
        
        return f"""
=== Proxy Rotasyon Raporu ===
Çalışma süresi: {uptime}
Toplam istek: {self.stats["total_requests"]}
Başarılı: {self.stats["successful"]} ({success_rate:.1f}%)
Hata: {self.stats["failed"]}

Sorunlu proxy'ler:
{self._format_errors()}
        """
    
    def _format_errors(self):
        sorted_errors = sorted(
            self.stats["proxy_errors"].items(),
            key=lambda x: x[1],
            reverse=True
        )
        return "\n".join([f"  {proxy}: {count} hata" for proxy, count in sorted_errors[:5]])

# Rotator ile entegrasyon
monitor = ProxyMonitor()

# İstek döngüsünde:
try:
    response = rotator.request_with_retry(url)
    monitor.log_request(current_proxy, success=True)
except Exception as e:
    monitor.log_request(current_proxy, success=False, error=str(e))

En İyi Uygulamalar ve Trafik Kullanımı Optimizasyonu

Proxy rotasyon otomasyonundan maksimum verim almak için kanıtlanmış uygulamaları takip edin:

1. Görev için doğru proxy türünü seçin

• Residential proxy'ler — sosyal medya, marketplace'ler, yüksek güvenlikli siteler için
• Datacenter proxy'ler — hız önemliyse genel scraping için
• Mobil proxy'ler — mobil uygulamalar ve agresif antibot sistemleri için

2. İstekler arasında gecikme uygulayın

Proxy değiştirseniz bile, aynı IP'den saniyede 100 istek şüphe uyandırır. İnsan davranışını taklit edin:

import random
import time

def human_delay():
    """İnsan benzeri rastgele gecikme"""
    delay = random.uniform(1.5, 4.5)  # 1.5-4.5 saniye
    time.sleep(delay)

# İstekler arasında kullanım
for url in urls:
    response = session.get(url)
    process_data(response)
    human_delay()  # Sonraki istekten önce bekle

3. Proxy havuzunu izleyin ve temizleyin

Düzenli olarak çalışmayan proxy'leri kaldırın ve yenileriyle değiştirin:

def test_proxy(proxy):
    """Proxy'nin çalışıp çalışmadığını kontrol et"""
    try:
        response = requests.get(
            "https://api.ipify.org",
            proxies={"http": proxy, "https": proxy},
            timeout=5
        )
        return response.status_code == 200
    except:
        return False

# Havuzu temizle
working_proxies = [p for p in proxy_list if test_proxy(p)]
print(f"Çalışan proxy: {len(working_proxies)}/{len(proxy_list)}")

4. Coğrafi hedefleme kullanın

Belirli bir ülkeden veri topluyorsanız, o bölgeden proxy kullanın — bu engelleme riskini azaltır:

# API üzerinden belirli ülkeden proxy al
response = requests.get(
    "https://api.provider.com/v1/proxy/list",
    params={"country": "TR", "city": "Istanbul"},
    headers={"Authorization": f"Bearer {API_KEY}"}
)

turkish_proxies = response.json()["data"]["proxies"]

5. Trafik kullanımını optimize edin

• Gereksiz kaynakları (resimler, CSS, fontlar) yüklemekten kaçının
• Yanıtları önbelleğe alın — aynı veriyi iki kez indirmeyin
• Sıkıştırma kullanın (gzip, brotli)

# Puppeteer'da kaynakları engelleme
await page.setRequestInterception(true);
page.on('request', (req) => {
    if(['image', 'stylesheet', 'font'].includes(req.resourceType())){
        req.abort();
    } else {
        req.continue();
    }
});

Sonuç

API üzerinden proxy rotasyon otomasyonu, modern scraping, arbitraj ve çoklu hesap yönetiminin temelidir. Doğru uygulama ile şunları elde edersiniz:

• Engelleme riskini %90'a kadar azaltma
• Veri toplama hızını 10-50 kat artırma
• Onlarca ve yüzlerce hesabı yönetme sürecini otomatikleştirme
• Trafik maliyetlerini 30-40% optimize etme

Bu kılavuzdaki örneklerle başlayın, bunları görevinize uyarlayın ve proxy havuzunuzun performansını izleyin. Unutmayın: en iyi otomasyon, teknolojiyi hedef sitenin özelliklerini ve kendi iş süreçlerinizi anlayarak birleştiren otomasyondur.