Cách nhận thống kê sử dụng proxy qua API: tự động hóa việc theo dõi lưu lượng truy cập

Nếu bạn làm việc với một số lượng lớn proxy — cho việc phân tích, thu thập dữ liệu hoặc quản lý nhiều tài khoản — việc kiểm soát thủ công lưu lượng trở thành một cơn ác mộng. API của các nhà cung cấp proxy cho phép tự động hóa việc nhận thống kê: số dư lưu lượng, phiên hoạt động, tiêu thụ theo địa chỉ IP và lịch sử sử dụng. Trong hướng dẫn này, chúng ta sẽ xem xét cách tích hợp API để theo dõi thống kê với các ví dụ mã trên Python, Node.js và cURL.

Tại sao cần tự động hóa thống kê proxy

Khi bạn quản lý từ 10-50 proxy cho các dự án khác nhau, việc kiểm tra thủ công số dư và tiêu thụ lưu lượng qua tài khoản cá nhân của nhà cung cấp trở nên không hiệu quả. API giải quyết một số vấn đề quan trọng:

Đối với những người làm tiếp thị, những người chạy quảng cáo qua nhiều tài khoản, việc biết được proxy nào đang hoạt động và còn bao nhiêu lưu lượng là cực kỳ quan trọng — việc bị chặn đột ngột do hết giới hạn có thể khiến bạn mất hàng nghìn đô la lợi nhuận. Đối với các công ty SMM, quản lý tài khoản khách hàng trên Instagram hoặc TikTok, tự động hóa cho phép lập hóa đơn chính xác cho việc sử dụng proxy.

Các trình thu thập dữ liệu từ các thị trường (Wildberries, Ozon, Avito) có thể tự động chuyển sang các proxy dự phòng khi hết giới hạn trên các proxy chính. API cho phép xây dựng các hệ thống chống chịu lỗi, hoạt động 24/7 mà không cần can thiệp thủ công.

Cơ bản về làm việc với API của nhà cung cấp proxy

Hầu hết các nhà cung cấp proxy hiện đại đều cung cấp API RESTful để quản lý dịch vụ. API hoạt động theo sơ đồ tiêu chuẩn: bạn gửi yêu cầu HTTP đến một endpoint cụ thể với các tham số xác thực, máy chủ trả về JSON với dữ liệu.

Cấu trúc JSON phản hồi điển hình từ API của nhà cung cấp proxy trông như thế này:

{
  "status": "success",
  "data": {
    "balance": 1250.50,
    "traffic_used_gb": 45.2,
    "traffic_remaining_gb": 54.8,
    "active_proxies": 15,
    "last_updated": "2024-01-15T10:30:00Z"
  },
  "error": null
}

Khi làm việc với API, điều quan trọng là phải xem xét giới hạn tần suất (rate limits). Hầu hết các nhà cung cấp cho phép từ 60-300 yêu cầu mỗi phút. Để theo dõi thống kê, điều này là đủ — thường thì các yêu cầu được thực hiện mỗi 5-15 phút.

Xác thực và nhận API-ключ

Bước đầu tiên trong việc làm việc với API là nhận được khóa xác thực. Quy trình này khác nhau giữa các nhà cung cấp, nhưng logic chung là giống nhau:

Có hai phương pháp xác thực chính trong API của các nhà cung cấp proxy:

Quan trọng: không bao giờ lưu trữ API-ключ trong mã mà có thể được đưa vào kho Git. Sử dụng biến môi trường (tệp .env) hoặc trình quản lý bí mật (AWS Secrets Manager, HashiCorp Vault). Nếu khóa bị rò rỉ — hãy ngay lập tức thu hồi nó trong tài khoản và tạo một cái mới.

Các endpoint chính để nhận thống kê

Mặc dù mỗi nhà cung cấp có cấu trúc API riêng, hầu hết đều cung cấp một bộ endpoint tiêu chuẩn để nhận thống kê. Hãy xem xét các phương pháp điển hình:

Các tham số yêu cầu thường bao gồm khoảng thời gian và bộ lọc:

GET /statistics?from=2024-01-01&to=2024-01-15&proxy_type=residential
GET /traffic/history?period=7d&group_by=day
GET /sessions/active?status=online&country=US

Đối với việc làm việc với proxy dân cư, endpoint nhận thống kê theo phiên là đặc biệt quan trọng, vì chúng thường sử dụng xoay vòng IP. API cho phép theo dõi số lượng IP duy nhất đã được sử dụng trong khoảng thời gian và khối lượng lưu lượng đã đi qua mỗi phiên.

Ví dụ mã trên Python để nhận thống kê

Python là ngôn ngữ phổ biến nhất để tự động hóa công việc với proxy nhờ vào thư viện requests. Hãy xem xét các ví dụ thực tế để nhận thống kê qua API.

Yêu cầu cơ bản về số dư và lưu lượng

import requests
import os
from datetime import datetime

# Thông tin xác thực API từ biến môi trường
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Nhận số dư và thống kê tổng thể"""
    headers = {
        'Authorization': f'Bearer {API_KEY}',
        'Content-Type': 'application/json'
    }
    
    try:
        response = requests.get(
            f'{BASE_URL}/balance',
            headers=headers,
            timeout=10
        )
        response.raise_for_status()
        
        data = response.json()
        
        print(f"=== Thống kê proxy vào {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Số dư: ${data['balance']:.2f}")
        print(f"Lưu lượng đã sử dụng: {data['traffic_used_gb']:.2f} GB")
        print(f"Số lượng lưu lượng còn lại: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Số proxy đang hoạt động: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Lỗi khi yêu cầu: {e}")
        return None

# Gọi hàm
stats = get_balance_statistics()

Nhận thống kê chi tiết theo khoảng thời gian

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Nhận lịch sử tiêu thụ lưu lượng trong N ngày"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Tính toán khoảng thời gian
    end_date = datetime.now()
    start_date = end_date - timedelta(days=days)
    
    params = {
        'from': start_date.strftime('%Y-%m-%d'),
        'to': end_date.strftime('%Y-%m-%d'),
        'group_by': 'day'
    }
    
    response = requests.get(
        f'{BASE_URL}/traffic/history',
        headers=headers,
        params=params,
        timeout=10
    )
    
    if response.status_code == 200:
        data = response.json()
        
        print(f"\n=== Tiêu thụ lưu lượng trong {days} ngày qua ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} yêu cầu)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nTổng cộng trong khoảng thời gian: {total:.2f} GB")
        
        return data
    else:
        print(f"Lỗi {response.status_code}: {response.text}")
        return None

# Nhận thống kê trong một tuần
history = get_traffic_history(7)

Theo dõi thống kê theo proxy riêng lẻ

def get_proxy_statistics(proxy_id):
    """Nhận thống kê cho một proxy cụ thể"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    response = requests.get(
        f'{BASE_URL}/statistics/proxy/{proxy_id}',
        headers=headers,
        timeout=10
    )
    
    if response.status_code == 200:
        data = response.json()
        
        print(f"\n=== Thống kê proxy {proxy_id} ===")
        print(f"Địa chỉ IP: {data['ip_address']}")
        print(f"Quốc gia: {data['country']}")
        print(f"Loại: {data['proxy_type']}")
        print(f"Trạng thái: {data['status']}")
        print(f"Lưu lượng đã sử dụng: {data['traffic_used_mb']:.2f} MB")
        print(f"Số lượng yêu cầu: {data['total_requests']}")
        print(f"Hoạt động cuối cùng: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} không được tìm thấy")
        return None

def get_all_proxies_stats():
    """Nhận thống kê cho tất cả các proxy"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Đầu tiên nhận danh sách tất cả các proxy
    response = requests.get(
        f'{BASE_URL}/proxies/list',
        headers=headers,
        timeout=10
    )
    
    if response.status_code == 200:
        proxies = response.json()['proxies']
        
        print(f"\n=== Thống kê cho {len(proxies)} proxy ===\n")
        
        total_traffic = 0
        for proxy in proxies:
            stats = get_proxy_statistics(proxy['id'])
            if stats:
                total_traffic += stats['traffic_used_mb']
        
        print(f"\n=== Tổng tiêu thụ lưu lượng: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Lỗi khi nhận danh sách proxy")
        return None

# Nhận thống kê cho tất cả các proxy
all_stats = get_all_proxies_stats()

Những ví dụ này cho thấy cách làm việc cơ bản với API. Đối với các hệ thống sản xuất, hãy thêm xử lý lỗi, logic retry khi gặp sự cố mạng và lưu trữ kết quả để không vượt quá giới hạn tần suất của nhà cung cấp.

Ví dụ mã trên Node.js để theo dõi lưu lượng

Node.js rất phù hợp để tạo ra các microservices theo dõi, hoạt động trong nền và gửi thông báo khi có sự kiện quan trọng. Sử dụng thư viện axios để thực hiện các yêu cầu HTTP.

Lớp cơ bản để làm việc với API proxy

const axios = require('axios');
require('dotenv').config();

class ProxyAPIClient {
  constructor() {
    this.baseURL = 'https://api.proxyprovider.com/v1';
    this.apiKey = process.env.PROXY_API_KEY;
    
    this.client = axios.create({
      baseURL: this.baseURL,
      timeout: 10000,
      headers: {
        'Authorization': `Bearer ${this.apiKey}`,
        'Content-Type': 'application/json'
      }
    });
  }

  async getBalance() {
    try {
      const response = await this.client.get('/balance');
      return response.data;
    } catch (error) {
      console.error('Lỗi khi nhận số dư:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Lỗi khi nhận thống kê:', error.message);
      throw error;
    }
  }

  async getTrafficHistory(days = 7) {
    const endDate = new Date();
    const startDate = new Date();
    startDate.setDate(startDate.getDate() - days);

    const params = {
      from: startDate.toISOString().split('T')[0],
      to: endDate.toISOString().split('T')[0],
      group_by: 'day'
    };

    try {
      const response = await this.client.get('/traffic/history', { params });
      return response.data;
    } catch (error) {
      console.error('Lỗi khi nhận lịch sử lưu lượng:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Lỗi khi nhận thống kê proxy ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Theo dõi tự động với thông báo

const ProxyAPIClient = require('./ProxyAPIClient');
const nodemailer = require('nodemailer');

class ProxyMonitor {
  constructor(checkIntervalMinutes = 15) {
    this.api = new ProxyAPIClient();
    this.checkInterval = checkIntervalMinutes * 60 * 1000;
    this.thresholds = {
      trafficWarning: 10, // GB - cảnh báo
      trafficCritical: 5,  // GB - mức độ nghiêm trọng
      balanceWarning: 50   // USD - cảnh báo về số dư
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Kiểm tra thống kê...`);
      console.log(`Số dư: $${balance.balance.toFixed(2)}`);
      console.log(`Số lượng lưu lượng còn lại: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Kiểm tra các ngưỡng quan trọng
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `CÓ QUÁ ÍT LƯU LƯỢNG: còn lại ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Ít lưu lượng: còn lại ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

      if (balance.balance <= this.thresholds.balanceWarning) {
        alerts.push({
          level: 'warning',
          message: `Số dư thấp: $${balance.balance.toFixed(2)}`
        });
      }

      // Gửi thông báo
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('Lỗi theo dõi:', error);
      await this.sendErrorNotification(error);
    }
  }

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  CHÚ Ý! Đã phát hiện vấn đề:');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // Gửi email (cấu hình SMTP)
    const transporter = nodemailer.createTransport({
      host: process.env.SMTP_HOST,
      port: process.env.SMTP_PORT,
      auth: {
        user: process.env.SMTP_USER,
        pass: process.env.SMTP_PASS
      }
    });

    const emailBody = `
      Đã phát hiện vấn đề với proxy:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Thống kê hiện tại:
      - Số dư: $${balance.balance.toFixed(2)}
      - Số lượng lưu lượng còn lại: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Đã sử dụng: ${balance.traffic_used_gb.toFixed(2)} GB
      - Số proxy đang hoạt động: ${balance.active_proxies}
      
      Khuyến nghị nạp lại số dư hoặc giảm tải.
    `;

    await transporter.sendMail({
      from: process.env.ALERT_FROM_EMAIL,
      to: process.env.ALERT_TO_EMAIL,
      subject: '⚠️ Cảnh báo về proxy',
      text: emailBody
    });
  }

  start() {
    console.log(`Khởi động theo dõi proxy (kiểm tra mỗi ${this.checkInterval / 60000} phút)`);
    
    // Kiểm tra đầu tiên ngay lập tức
    this.checkAndNotify();
    
    // Kiểm tra định kỳ
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Khởi động theo dõi
const monitor = new ProxyMonitor(15); // kiểm tra mỗi 15 phút
monitor.start();

Mã này tạo ra một dịch vụ nền, kiểm tra thống kê mỗi 15 phút và gửi thông báo qua email khi đạt đến các ngưỡng quan trọng. Đối với proxy di động, thường đắt hơn proxy dân cư, việc theo dõi này đặc biệt quan trọng để kiểm soát chi phí.

Ví dụ yêu cầu qua cURL

cURL là công cụ đa năng để kiểm tra API từ dòng lệnh. Hữu ích cho việc kiểm tra nhanh các endpoint và gỡ lỗi tích hợp.

Nhận số dư

# Yêu cầu cơ bản để nhận số dư
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Với định dạng JSON đẹp (qua jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Trích xuất một trường cụ thể
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Nhận thống kê theo khoảng thời gian

# Thống kê trong 7 ngày qua
curl -X GET "https://api.proxyprovider.com/v1/traffic/history?from=2024-01-08&to=2024-01-15&group_by=day" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.daily_stats'

# Thống kê theo loại proxy cụ thể
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Nhận danh sách các proxy đang hoạt động

# Danh sách tất cả các proxy đang hoạt động
curl -X GET "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies[] | {id, ip_address, country, proxy_type}'

# Đếm số lượng proxy đang hoạt động
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Bash-script để kiểm tra tự động

#!/bin/bash

# Cấu hình
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - ngưỡng cảnh báo

# Nhận thống kê
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

# Phân tích JSON
traffic_remaining=$(echo "$response" | jq -r '.traffic_remaining_gb')
balance=$(echo "$response" | jq -r '.balance')
active_proxies=$(echo "$response" | jq -r '.active_proxies')

# Xuất thống kê
echo "=== Thống kê proxy $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Số lượng lưu lượng còn lại: ${traffic_remaining} GB"
echo "Số dư: \$${balance}"
echo "Số proxy đang hoạt động: ${active_proxies}"

# Kiểm tra ngưỡng
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  CHÚ Ý: Ít lưu lượng! Còn lại ${traffic_remaining} GB"
  
  # Gửi thông báo (ví dụ qua Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Ít lưu lượng proxy: ${traffic_remaining} GB"
fi

Lưu mã này dưới dạng check_proxy_stats.sh, cấp quyền thực thi (chmod +x check_proxy_stats.sh) và thêm vào cron để tự động chạy mỗi giờ:

0 * * * * /path/to/check_proxy_stats.sh >> /var/log/proxy_monitor.log 2>&1

Tự động hóa theo dõi và thông báo

Việc kiểm tra thống kê thủ công không hiệu quả — cần có tự động hóa với thông báo thông minh. Hãy xem xét một hệ thống theo dõi hoàn chỉnh với các tích hợp.

Tích hợp với Telegram để thông báo

import requests
import os
from datetime import datetime

class TelegramNotifier:
    def __init__(self):
        self.bot_token = os.getenv('TELEGRAM_BOT_TOKEN')
        self.chat_id = os.getenv('TELEGRAM_CHAT_ID')
        self.base_url = f'https://api.telegram.org/bot{self.bot_token}'
    
    def send_message(self, text, parse_mode='Markdown'):
        """Gửi tin nhắn đến Telegram"""
        url = f'{self.base_url}/sendMessage'
        payload = {
            'chat_id': self.chat_id,
            'text': text,
            'parse_mode': parse_mode
        }
        
        try:
            response = requests.post(url, json=payload, timeout=10)
            return response.status_code == 200
        except Exception as e:
            print(f"Lỗi gửi đến Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Theo dõi với thông báo đến Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Tạo tin nhắn
        message = f"""
📊 *Thống kê proxy* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Số dư: ${balance['balance']:.2f}
📈 Đã sử dụng: {balance['traffic_used_gb']:.2f} GB
📉 Còn lại: {balance['traffic_remaining_gb']:.2f} GB
🔌 Số proxy đang hoạt động: {balance['active_proxies']}
        """
        
        # Kiểm tra các ngưỡng quan trọng
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *CÓ QUÁ ÍT LƯU LƯỢNG!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Khuyến nghị nạp thêm lưu lượng"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Lỗi theo dõi proxy*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Khởi động theo dõi
monitor_proxy_with_telegram()

Tích hợp với Slack

import requests
import json

class SlackNotifier:
    def __init__(self, webhook_url):
        self.webhook_url = webhook_url
    
    def send_alert(self, title, message, level='warning'):
        """Gửi thông báo đến Slack"""
        color = {
            'info': '#36a64f',
            'warning': '#ff9900',
            'critical': '#ff0000'
        }.get(level, '#cccccc')
        
        payload = {
            'attachments': [{
                'color': color,
                'title': title,
                'text': message,
                'footer': 'Proxy Monitor',
                'ts': int(datetime.now().timestamp())
            }]
        }
        
        try:
            response = requests.post(
                self.webhook_url,
                data=json.dumps(payload),
                headers={'Content-Type': 'application/json'},
                timeout=10
            )
            return response.status_code == 200
        except Exception as e:
            print(f"Lỗi gửi đến Slack: {e}")
            return False

def check_proxy_health():
    """Kiểm tra tình trạng proxy với thông báo"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Phân tích tình trạng
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Đã phát hiện {len(offline_proxies)} proxy không hoạt động:\n"
        for proxy in offline_proxies[:5]:  # 5 cái đầu tiên
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Proxy không hoạt động',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Còn quá ít lưu lượng!',
            f"Còn lại {balance['traffic_remaining_gb']:.2f} GB. "
            f"Số dư: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Cài đặt tự động nạp tiền

Một số nhà cung cấp cho phép thông qua API không chỉ nhận thống kê mà còn tự động nạp lại số dư khi đạt đến ngưỡng:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Tự động nạp tiền khi số dư thấp"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Lưu lượng dưới ngưỡng ({threshold_gb} GB), bắt đầu nạp tiền...")
        
        # Yêu cầu nạp tiền qua API
        topup_response = requests.post(
            f'{api.base_url}/billing/topup',
            headers={'Authorization': f'Bearer {api.api_key}'},
            json={
                'amount': topup_amount_usd,
                'payment_method': 'card',
                'auto_topup': True
            },
            timeout=10
        )
        
        if topup_response.status_code == 200:
            print(f"✅ Đã nạp thêm ${topup_amount_usd}")
            
            # Gửi thông báo
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Tự động nạp tiền\n\n"
                f"Số tiền: ${topup_amount_usd}\n"
                f"Đã có lưu lượng: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Lý do: đã đạt ngưỡng {threshold_gb} GB"
            )
        else:
            print(f"❌ Lỗi nạp tiền: {topup_response.text}")
    else:
        print(f"Có đủ lưu lượng: {balance['traffic_remaining_gb']:.2f} GB")

# Khởi động kiểm tra (có thể thêm vào cron)
auto_topup_if_needed()

Tạo bảng điều khiển thống kê riêng

Để trực quan hóa dữ liệu từ API, bạn có thể tạo một bảng điều khiển web với các biểu đồ về tiêu thụ lưu lượng, phân bổ theo quốc gia và loại proxy. Hãy xem xét một ví dụ đơn giản trên Flask + Chart.js.

Backend trên Flask

from flask import Flask, jsonify, render_template
from datetime import datetime, timedelta
import requests

app = Flask(__name__)

class ProxyDashboard:
    def __init__(self):
        self.api_key = os.getenv('PROXY_API_KEY')
        self.base_url = 'https://api.proxyprovider.com/v1'
    
    def get_dashboard_data(self):
        """Nhận tất cả dữ liệu cho bảng điều khiển"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Số dư và thống kê tổng thể
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Lịch sử trong 30 ngày qua
        end_date = datetime.now()
        start_date = end_date - timedelta(days=30)
        
        history = requests.get(
            f'{self.base_url}/traffic/history',
            headers=headers,
            params={
                'from': start_date.strftime('%Y-%m-%d'),
                'to': end_date.strftime('%Y-%m-%d'),
                'group_by': 'day'
            }
        ).json()
        
        # Danh sách proxy
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Tập hợp dữ liệu
        traffic_by_country = {}
        traffic_by_type = {}
        
        for proxy in proxies.get('proxies', []):
            country = proxy.get('country', 'Unknown')
            proxy_type = proxy.get('proxy_type', 'Unknown')
            traffic = proxy.get('traffic_used_mb', 0) / 1024  # chuyển đổi sang GB
            
            traffic_by_country[country] = traffic_by_country.get(country, 0) + traffic
            traffic_by_type[proxy_type] = traffic_by_type.get(proxy_type, 0) + traffic
        
        return {
            'balance': balance,
            'history': history.get('daily_stats', []),
            'traffic_by_country': traffic_by_country,
            'traffic_by_type': traffic_by_type,
            'total_proxies': len(proxies.get('proxies', []))
        }

dashboard = ProxyDashboard()

@app.route('/')
def index():
    """Trang chính của bảng điều khiển"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """API endpoint để nhận thống kê"""
    try:
        data = dashboard.get_dashboard_data()
        return jsonify(data)
    except Exception as e:
        return jsonify({'error': str(e)}), 500

if __name__ == '__main__':
    app.run(debug=True, port=5000)

Frontend với biểu đồ (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Bảng điều khiển thống kê Proxy</title>
  <script src="https://cdn.jsdelivr.net/npm/chart.js"></script>
  <style>
    body { font-family: Arial, sans-serif; padding: 20px; background: #f5f5f5; }
    .stats-card { background: white; padding: 20px; margin: 10px; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
    .stat-value { font-size: 2rem; font-weight: bold; color: #2563eb; }
    .chart-container { height: 300px; margin: 20px 0; }
  </style>
</head>
<body>
  <h1>📊 Bảng điều khiển thống kê Proxy</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Số dư</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Số lượng lưu lượng còn lại</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Đã sử dụng</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Số proxy đang hoạt động</div>
      <div class="stat-value" id="active-proxies">-</div>
    </div>
  </div>

  <div class="chart-container">
    <canvas id="trafficChart"></canvas>
  </div>

  <script>
    async function fetchStats() {
      const response = await fetch('/api/stats');
      const data = await response.json();
      document.getElementById('balance').innerText = data.balance.balance.toFixed(2);
      document.getElementById('traffic-remaining').innerText = data.balance.traffic_remaining_gb.toFixed(2);
      document.getElementById('traffic-used').innerText = data.balance.traffic_used_gb.toFixed(2);
      document.getElementById('active-proxies').innerText = data.balance.active_proxies;

      const labels = data.history.map(day => day.date);
      const trafficData = data.history.map(day => day.traffic_gb);
      
      const ctx = document.getElementById('trafficChart').getContext('2d');
      new Chart(ctx, {
        type: 'line',
        data: {
          labels: labels,
          datasets: [{
            label: 'Lưu lượng đã sử dụng (GB)',
            data: trafficData,
            borderColor: 'rgba(75, 192, 192, 1)',
            borderWidth: 2,
            fill: false
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

    fetchStats();
  </script>
</body>
</html>