Tự động hóa chuyển đổi proxy qua API: cách thiết lập luân phiên cho việc thu thập dữ liệu và arbitrage

Thay đổi proxy thủ công khi làm việc với hàng trăm request là lãng phí thời gian và tiền bạc. API rotation cho phép tự động chuyển đổi địa chỉ IP khi bị chặn, phân phối tải và mở rộng quy mô parsing hoặc multi-accounting. Trong hướng dẫn này, chúng ta sẽ tìm hiểu cách thiết lập tự động thay đổi proxy cho các tác vụ khác nhau: từ parsing marketplace đến farming tài khoản Facebook Ads.

Tài liệu phù hợp cho cả developer viết parser bằng Python hoặc Node.js, và arbitrageur sử dụng công cụ có sẵn với tích hợp API.

Tại sao cần tự động hóa thay đổi proxy qua API

Rotation tự động địa chỉ IP qua API giải quyết một số tác vụ quan trọng mà các chuyên gia trong các lĩnh vực khác nhau gặp phải:

Ưu điểm chính của tự động hóa API so với thay đổi thủ công:

• Tốc độ: Thay đổi IP diễn ra trong vài mili giây bằng lập trình, không cần sự tham gia của con người
• Khả năng mở rộng: Có thể quản lý hàng nghìn proxy đồng thời qua giao diện thống nhất
• Khả năng chịu lỗi: Tự động thay thế proxy không hoạt động mà không dừng quy trình
• Linh hoạt: Thiết lập quy tắc rotation cho tác vụ cụ thể: theo thời gian, theo số lượng request, theo địa lý
• Tiết kiệm: Sử dụng traffic tối ưu thông qua cân bằng tải

Kịch bản sử dụng điển hình: bạn parse giá đối thủ trên Wildberries. Không có API, bạn cần theo dõi thủ công các lần bị chặn, vào bảng điều khiển nhà cung cấp proxy, sao chép dữ liệu mới, dán vào script. Với API, tất cả diễn ra tự động: script nhận lỗi 429 (Too Many Requests), gửi request đến API dịch vụ proxy, nhận IP mới và tiếp tục làm việc.

Các loại rotation proxy: sticky sessions vs tự động thay đổi

Trước khi thiết lập tự động hóa, quan trọng là hiểu sự khác biệt giữa các loại rotation địa chỉ IP. Lựa chọn chiến lược phụ thuộc vào tác vụ của bạn.

Sticky Sessions (proxy theo session)

Khi sử dụng sticky sessions, một địa chỉ IP được gắn với session của bạn trong thời gian nhất định (thường từ 5 đến 30 phút). Thay đổi chỉ xảy ra sau khi hết thời gian session hoặc theo API request của bạn.

Khi nào sử dụng:

• Làm việc với tài khoản mạng xã hội (Instagram, Facebook) — thay đổi IP thường xuyên gây nghi ngờ
• Điền form nhiều trang, cần giữ session
• Test quảng cáo từ khu vực cụ thể trong suốt session
• Parse website có đăng nhập, thay đổi IP sẽ dẫn đến logout

Ví dụ API request để tạo sticky session (thường sử dụng định dạng login đặc biệt):

// Định dạng: username-session-SESSIONID:password
// SESSIONID — chuỗi bất kỳ, giống nhau = một IP

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

// Tất cả request với session-abc123 sẽ nhận một IP trong thời gian session
// Để có IP mới, sử dụng SESSIONID khác: session-xyz789

Rotation tự động mỗi request

Địa chỉ IP thay đổi mỗi khi kết nối mới đến proxy server. Đây là hành vi tiêu chuẩn của residential proxy không chỉ định tham số session.

Khi nào sử dụng:

• Parsing hàng loạt không cần đăng nhập (giá, liên hệ, tin đăng)
• Vượt qua rate limits khắt khe trên public API
• Thu thập dữ liệu từ website ban IP sau 10-20 request
• Kiểm tra khả năng truy cập nội dung từ các khu vực khác nhau

Ví dụ sử dụng trong Python (mỗi request = IP mới):

import requests

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

# Mỗi request sẽ nhận IP mới
for i in range(10):
    response = requests.get("https://api.ipify.org", proxies=proxy)
    print(f"Request {i+1}, IP: {response.text}")

Rotation theo timer

Bạn kiểm soát lập trình khi nào thay đổi IP: mỗi N phút, sau M request hoặc khi nhận lỗi cụ thể. Đây là cách tiếp cận hybrid, được thực hiện qua API của dịch vụ proxy.

Khi nào sử dụng:

• Tối ưu hóa tiêu thụ traffic — chỉ thay đổi khi cần thiết
• Làm việc với website theo dõi pattern (thay đổi quá thường xuyên = ban)
• Cân bằng giữa ẩn danh và tính ổn định của session

Cơ bản về làm việc với API của dịch vụ proxy

Hầu hết các nhà cung cấp proxy hiện đại cung cấp hai cách quản lý: qua web panel và qua API. API cho phép truy cập lập trình vào các chức năng: lấy danh sách proxy, tạo session mới, kiểm tra số dư, thống kê sử dụng.

Các phương thức API điển hình của dịch vụ proxy

Mặc dù mỗi nhà cung cấp có tài liệu riêng, các phương thức tiêu chuẩn thường bao gồm:

• GET /api/v1/proxy/list — lấy danh sách proxy có sẵn với lọc theo quốc gia, loại
• POST /api/v1/proxy/rotate — buộc thay đổi IP trong session đang hoạt động
• GET /api/v1/account/balance — kiểm tra traffic còn lại hoặc số dư tài khoản
• GET /api/v1/stats — thống kê sử dụng: lưu lượng traffic, số request, lỗi
• POST /api/v1/session/create — tạo sticky session mới với tham số (quốc gia, thành phố, thời lượng)

Xác thực thường thông qua API key trong header request:

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

Response thường ở định dạng JSON:

{
  "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
  }
}

Quản lý session qua API

Cho các tác vụ yêu cầu kiểm soát thời gian sống của IP (multi-accounting, làm việc với tài khoản), sử dụng tạo session có tên qua API. Điều này cho phép quản lý lập trình hàng chục và hàng trăm địa chỉ IP cô lập.

Ví dụ tạo session với tham số:

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

// Response:
{
  "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"
  }
}

Bây giờ bạn có thể sử dụng proxy này trong script hoặc trình duyệt antidetect của mình, và IP sẽ không đổi trong 10 phút. Để gia hạn session, gửi lại request với cùng session_id.

Ví dụ tự động hóa bằng Python: requests, Selenium, Scrapy

Python là ngôn ngữ phổ biến nhất cho parsing và tự động hóa. Hãy xem các ví dụ tích hợp API rotation proxy với các công cụ chính.

Tự động thay đổi proxy trong requests

Thư viện requests được sử dụng cho HTTP request đơn giản. Để rotation tự động, tạo class wrapper thay đổi proxy khi có lỗi:

import requests
import random
import time

class RotatingProxySession:
    def __init__(self, proxy_list):
        """
        proxy_list: danh sách dict với dữ liệu proxy
        [{"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):
        """Chọn proxy ngẫu nhiên từ danh sách"""
        self.current_proxy = random.choice(self.proxy_list)
        self.session.proxies.update(self.current_proxy)
        print(f"Đã chuyển sang proxy: {self.current_proxy['http']}")
    
    def get(self, url, max_retries=3, **kwargs):
        """GET request với rotation tự động khi có lỗi"""
        for attempt in range(max_retries):
            try:
                response = self.session.get(url, timeout=10, **kwargs)
                
                # Nếu bị chặn — đổi proxy
                if response.status_code in [403, 429, 503]:
                    print(f"Nhận {response.status_code}, đổi proxy...")
                    self.rotate()
                    time.sleep(2)
                    continue
                
                return response
                
            except requests.exceptions.ProxyError:
                print(f"Proxy không hoạt động, thử {attempt+1}/{max_retries}")
                self.rotate()
                time.sleep(2)
            
            except requests.exceptions.Timeout:
                print("Timeout, đổi proxy...")
                self.rotate()
                time.sleep(2)
        
        raise Exception(f"Không thể thực hiện request sau {max_retries} lần thử")

# Sử dụng:
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)

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

Tích hợp với Selenium cho tự động hóa trình duyệt

Selenium được sử dụng để parse website có JavaScript và tự động hóa hành động trong trình duyệt. Để thay đổi proxy cần tạo lại driver, vì cài đặt proxy được thiết lập khi khởi tạo:

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):
        """Tạo driver mới với proxy hiện tại"""
        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')  # không GUI
        
        self.driver = webdriver.Chrome(options=chrome_options)
        print(f"Đã tạo driver với proxy: {proxy}")
    
    def rotate(self):
        """Chuyển sang proxy tiếp theo"""
        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):
        """Mở URL với tự động đổi proxy khi có lỗi"""
        for attempt in range(max_retries):
            try:
                if not self.driver:
                    self.create_driver()
                
                self.driver.get(url)
                
                # Kiểm tra chặn (ví dụ tìm captcha)
                if "captcha" in self.driver.page_source.lower():
                    print("Phát hiện captcha, đổi proxy...")
                    self.rotate()
                    time.sleep(3)
                    continue
                
                return self.driver.page_source
                
            except Exception as e:
                print(f"Lỗi: {e}, đổi proxy (thử {attempt+1})")
                self.rotate()
                time.sleep(3)
        
        raise Exception("Không thể tải trang")

# Sử dụng:
proxies = [
    "http://user:pass@gate1.com:8000",
    "http://user:pass@gate2.com:8000",
]

bot = SeleniumRotatingProxy(proxies)

# Parse Ozon
for i in range(10):
    html = bot.get_with_retry(f"https://www.ozon.ru/category/page-{i}")
    print(f"Nhận HTML trang {i}, độ dài: {len(html)}")

bot.driver.quit()

Scrapy với middleware cho rotation proxy

Scrapy — framework cho parsing quy mô lớn. Rotation proxy được thực hiện qua middleware, tự động áp dụng cho tất cả request:

# 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):
        # Lấy danh sách proxy từ settings
        proxy_list = crawler.settings.getlist('ROTATING_PROXY_LIST')
        return cls(proxy_list)
    
    def process_request(self, request, spider):
        # Gán proxy ngẫu nhiên cho mỗi request
        proxy = random.choice(self.proxy_list)
        request.meta['proxy'] = proxy
        spider.logger.info(f'Sử dụng proxy: {proxy}')
    
    def process_exception(self, request, exception, spider):
        # Khi lỗi proxy — thử lại với proxy khác
        proxy = random.choice(self.proxy_list)
        spider.logger.warning(f'Lỗi proxy, chuyển sang: {proxy}')
        request.meta['proxy'] = proxy
        return request  # thử lại request

# 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',
]

# Thử lại request khi có lỗi
RETRY_TIMES = 5
RETRY_HTTP_CODES = [403, 429, 500, 502, 503]

Bây giờ mỗi request Scrapy tự động nhận proxy ngẫu nhiên từ danh sách, và khi có lỗi sẽ thử lại với IP khác.

Tự động hóa bằng Node.js: axios, Puppeteer, Playwright

Node.js phổ biến để tạo parser và bot nhờ tính bất đồng bộ và tích hợp tốt với công cụ trình duyệt. Hãy xem các ví dụ rotation proxy trong các thư viện chính.

Axios với rotation tự động

Axios — thư viện cho HTTP request. Tạo class với pool proxy và tự động thay thế khi có lỗi:

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
        });

        // Nếu bị chặn — thử tiếp
        if ([403, 429, 503].includes(response.status)) {
          console.log(`Status ${response.status}, đổi proxy...`);
          continue;
        }

        return response.data;

      } catch (error) {
        console.log(`Lỗi với proxy ${proxy}: ${error.message}`);
        if (i === maxRetries - 1) throw error;
      }
    }
  }
}

// Sử dụng:
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(`Trang ${page}: nhận ${data.length} sản phẩm`);
  }
})();

Puppeteer với rotation proxy

Puppeteer điều khiển trình duyệt Chrome. Proxy được thiết lập khi khởi động trình duyệt, nên để thay đổi cần tạo lại instance:

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(`Khởi động trình duyệt với proxy: ${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();
        
        // Xác thực proxy (nếu cần)
        await page.authenticate({
          username: 'your_username',
          password: 'your_password'
        });

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

        // Kiểm tra captcha
        const content = await page.content();
        if (content.includes('captcha')) {
          console.log('Phát hiện captcha, đổi proxy...');
          this.rotate();
          await this.createBrowser();
          continue;
        }

        return content;

      } catch (error) {
        console.log(`Lỗi: ${error.message}, thử ${i+1}`);
        this.rotate();
        await this.createBrowser();
      }
    }
    throw new Error('Không thể tải trang');
  }
}

// Sử dụng:
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(`Nhận HTML độ dài: ${html.length}`);
  await scraper.browser.close();
})();

Playwright với hỗ trợ rotation

Playwright — phương án hiện đại thay thế Puppeteer với hiệu suất tốt hơn. Cài đặt proxy tương tự:

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(`Lỗi tại ${url}: ${error.message}`);
    }

    await browser.close();
    
    // Proxy tiếp theo cho URL tiếp theo
    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);

Tích hợp API với trình duyệt antidetect: Dolphin Anty, AdsPower

Cho arbitrageur và chuyên gia SMM làm việc với multi-accounting, việc gán proxy thủ công cho từng profile trong Dolphin Anty hoặc AdsPower mất hàng giờ. API của các trình duyệt này cho phép tự động hóa tạo profile và gắn proxy.

Tự động hóa Dolphin Anty qua API

Dolphin Anty cung cấp API local (thường tại http://localhost:3001/v1.0), qua đó có thể tạo profile, gán proxy, khởi động trình duyệt bằng lập trình.

Ví dụ script Python để tạo hàng loạt profile với proxy duy nhất:

import requests
import json

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

# Danh sách proxy từ nhà cung cấp (lấy qua API của họ)
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):
    """Tạo profile trong Dolphin với gắn proxy"""
    
    payload = {
        "name": name,
        "tags": ["Facebook Ads", "Auto-created"],
        "proxy": {
            "type": "http",  # hoặc 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"✓ Đã tạo profile: {name}, ID: {profile['id']}")
        return profile['id']
    else:
        print(f"✗ Lỗi tạo {name}: {response.text}")
        return None

# Tạo 50 profile với rotation proxy
for i in range(50):
    proxy = proxies[i % len(proxies)]  # rotation vòng tròn
    profile_name = f"FB_Account_{i+1:03d}"
    create_profile_with_proxy(profile_name, proxy)

Bây giờ bạn có 50 profile trong Dolphin Anty, mỗi cái với fingerprint trình duyệt và proxy duy nhất. Để khởi động profile bằng lập trình:

def start_profile(profile_id):
    """Khởi động profile trình duyệt"""
    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"Profile đã khởi động, port WebDriver: {data['automation']['port']}")
        return data['automation']['port']
    else:
        print(f"Lỗi khởi động: {response.text}")

# Khởi động profile và điều khiển qua Selenium
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")

Tự động hóa AdsPower

AdsPower cũng cung cấp API local. Logic tương tự Dolphin, nhưng với endpoint khác:

import requests

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

def create_adspower_profile(name, proxy):
    payload = {
        "name": name,
        "group_id": "0",  # ID nhóm profile
        "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"✓ Đã tạo profile AdsPower: {name}, ID: {user_id}")
        return user_id
    else:
        print(f"✗ Lỗi: {response.json()['msg']}")

# Tạo profile
for i, proxy in enumerate(proxies):
    create_adspower_profile(f"TikTok_Account_{i+1}", proxy)

Tự động hóa như vậy cực kỳ quan trọng khi làm việc với hàng chục tài khoản. Thay vì sao chép thủ công dữ liệu proxy vào từng profile, bạn chạy script và có cơ sở hạ tầng sẵn sàng trong vài phút.

Xử lý lỗi và fallback tự động

Khi làm việc với proxy, không thể tránh khỏi các tình huống: IP bị chặn bởi website mục tiêu, proxy server không phản hồi, hết traffic. Xử lý lỗi đúng cách là chìa khóa cho tự động hóa ổn định.

Các loại lỗi và chiến lược xử lý

Triển khai hệ thống retry thông minh

Thay vì retry request đơn giản, tạo hệ thống với exponential backoff và blacklist proxy không hoạt động:

import requests
import time
from collections import defaultdict

class SmartProxyRotator:
    def __init__(self, proxy_list):
        self.proxy_list = proxy_list
        self.blacklist = set()  # IP không hoạt động
        self.error_count = defaultdict(int)  # đếm lỗi theo IP
        self.max_errors = 3  # sau 3 lỗi — vào blacklist
    
    def get_working_proxy(self):
        """Lấy proxy không trong blacklist"""
        available = [p for p in self.proxy_list if p not in self.blacklist]
        if not available:
            # Tất cả proxy bị ban — xóa blacklist
            print("⚠ Tất cả proxy bị chặn, reset blacklist")
            self.blacklist.clear()
            self.error_count.clear()
            available = self.proxy_list
        return available[0]
    
    def mark_error(self, proxy):
        """Đánh dấu lỗi proxy"""
        self.error_count[proxy] += 1
        if self.error_count[proxy] >= self.max_errors:
            self.blacklist.add(proxy)
            print(f"✗ Proxy {proxy} thêm vào blacklist")
    
    def request_with_retry(self, url, max_retries=5):
        """Request với retry thông minh"""
        for attempt in range(max_retries):
            proxy = self.get_working_proxy()
            
            try:
                # Exponential backoff: 1s, 2s, 4s, 8s...
                if attempt > 0:
                    delay = 2 ** attempt
                    print(f"Chờ {delay}s trước thử {attempt+1}")
                    time.sleep(delay)
                
                response = requests.get(
                    url,
                    proxies={"http": proxy, "https": proxy},
                    timeout=15
                )
                
                # Thành công — reset đếm lỗi
                if response.status_code == 200:
                    self.error_count[proxy] = 0
                    return response
                
                # Bị chặn — đổi proxy
                elif response.status_code in [403, 429]:
                    print(f"Status {response.status_code}, đổi proxy")
                    self.mark_error(proxy)
                    continue
                
            except requests.exceptions.ProxyError:
                print(f"ProxyError với {proxy}")
                self.mark_error(proxy)
                
            except requests.exceptions.Timeout:
                print(f"Timeout với {proxy}")
                self.mark_error(proxy)
        
        raise Exception(f"Không thể thực hiện request sau {max_retries} lần thử")

# Sử dụng:
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"✓ Trang {i}: {len(response.text)} byte")
    except Exception as e:
        print(f"✗ Lỗi nghiêm trọng tại trang {i}: {e}")

Giám sát và cảnh báo

Cho hệ thống production, quan trọng là theo dõi sức khỏe proxy pool theo thời gian thực. Thêm logging metrics:

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()
        }
        
        # Thiết lập logging
        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"✓ Thành công với {proxy}")
        else:
            self.stats["failed"] += 1
            self.stats["proxy_errors"][proxy] += 1
            logging.error(f"✗ Lỗi với {proxy}: {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"""
=== Báo cáo proxy rotation ===
Thời gian hoạt động: {uptime}
Tổng request: {self.stats["total_requests"]}
Thành công: {self.stats["successful"]} ({success_rate:.1f}%)
Lỗi: {self.stats["failed"]}

Proxy có vấn đề:
{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} lỗi" for proxy, count in sorted_errors[:5]])

# Tích hợp với rotator
monitor = ProxyMonitor()

# Trong vòng lặp request:
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))

Best practices và tối ưu hóa tiêu thụ traffic

Để tối đa hóa hiệu quả và giảm chi phí khi sử dụng proxy rotation tự động:

• Sử dụng sticky sessions khi có thể: Giảm tiêu thụ traffic và tránh trigger hệ thống phát hiện bot
• Implement caching: Lưu response thành công để tránh request lặp lại
• Respect rate limits: Thêm delay hợp lý giữa các request, ngay cả khi đổi IP
• Giám sát chi phí: Track traffic usage theo thời gian thực qua API của nhà cung cấp
• Sử dụng loại proxy phù hợp: Residential cho tác vụ nhạy cảm, datacenter cho parsing đơn giản
• Implement circuit breaker: Tạm dừng khi phát hiện quá nhiều lỗi liên tiếp

Kết luận

Tự động hóa thay đổi proxy qua API là kỹ năng thiết yếu cho bất kỳ ai làm việc với parsing quy mô lớn, multi-accounting hoặc arbitrage. Các ví dụ trong hướng dẫn này cung cấp nền tảng vững chắc để bạn xây dựng hệ thống riêng, tùy chỉnh theo nhu cầu cụ thể.

Hãy nhớ rằng proxy chất lượng cao là điều kiện tiên quyết cho thành công. ProxyCove cung cấp residential và mobile proxy với API mạnh mẽ, hỗ trợ tất cả các kịch bản rotation được mô tả trong bài viết này.