Como obter estatísticas de uso de proxy via API: automação do controle de tráfego

Se você trabalha com um grande número de proxies — para arbitragem, scraping ou multi-contas — o controle manual do consumo de tráfego se torna um pesadelo. A API dos provedores de proxy permite automatizar a obtenção de estatísticas: saldo de tráfego, sessões ativas, consumo por endereços IP e histórico de uso. Neste guia, vamos explorar como integrar a API para controle de estatísticas com exemplos de código em Python, Node.js e cURL.

Por que a automação das estatísticas de proxy é necessária

Quando você gerencia de 10 a 50 proxies para diferentes projetos, a verificação manual do saldo e do consumo de tráfego através do painel do provedor se torna ineficaz. A API resolve várias tarefas críticas:

Para os arbitradores que executam anúncios através de várias contas, é crucial saber quais proxies estão ativos e quanto tráfego resta — um bloqueio repentino devido ao limite esgotado pode custar milhares de dólares em lucros perdidos. Para agências de SMM que gerenciam contas de clientes no Instagram ou TikTok, a automação permite emitir faturas precisas pelo uso de proxies.

Scrapers de marketplaces (Wildberries, Ozon, Avito) podem alternar automaticamente para proxies de reserva ao esgotar o limite dos principais. A API permite construir sistemas tolerantes a falhas que funcionam 24/7 sem intervenção manual.

Fundamentos do trabalho com APIs de provedores de proxy

A maioria dos provedores de proxy modernos oferece uma API RESTful para gerenciar o serviço. A API funciona de acordo com um esquema padrão: você envia uma requisição HTTP para um determinado endpoint com parâmetros de autenticação, e o servidor retorna um JSON com os dados.

A estrutura típica da resposta JSON de um provedor de proxy se parece com isto:

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

Ao trabalhar com a API, é importante considerar os rate limits (limites de requisições). A maioria dos provedores permite de 60 a 300 requisições por minuto. Para monitorar estatísticas, isso é mais do que suficiente — normalmente as requisições são feitas a cada 5-15 minutos.

Autenticação e obtenção da chave da API

O primeiro passo para trabalhar com a API é obter a chave de autenticação. O processo varia entre os provedores, mas a lógica geral é a mesma:

Existem dois métodos principais de autenticação nas APIs dos provedores de proxy:

Importante: nunca armazene chaves da API em código que será enviado para um repositório Git. Use variáveis de ambiente (arquivos .env) ou gerenciadores de segredos (AWS Secrets Manager, HashiCorp Vault). Se a chave vazar — revogue-a imediatamente no painel e gere uma nova.

Principais endpoints para obtenção de estatísticas

Embora cada provedor tenha sua própria estrutura de API, a maioria oferece um conjunto padrão de endpoints para obtenção de estatísticas. Vamos considerar os métodos típicos:

Os parâmetros das requisições geralmente incluem intervalos de tempo e filtros:

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

Para trabalhar com proxies residenciais, o endpoint para obter estatísticas de sessões é especialmente importante, pois eles frequentemente utilizam rotação de IP. A API permite rastrear quantos IPs únicos foram usados durante o período e qual volume de tráfego passou por cada sessão.

Exemplos de código em Python para obtenção de estatísticas

Python é a linguagem mais popular para automação de trabalho com proxies, graças à biblioteca requests. Vamos considerar exemplos práticos de obtenção de estatísticas via API.

Requisição básica de saldo e tráfego

import requests
import os
from datetime import datetime

# Credenciais da API a partir das variáveis de ambiente
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Obtenção do saldo e estatísticas gerais"""
    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"=== Estatísticas do proxy em {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Saldo: ${data['balance']:.2f}")
        print(f"Tráfego utilizado: {data['traffic_used_gb']:.2f} GB")
        print(f"Saldo de tráfego: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Proxies ativos: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Erro na requisição: {e}")
        return None

# Chamada da função
stats = get_balance_statistics()

Obtenção de estatísticas detalhadas por período

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Obtenção do histórico de consumo de tráfego por N dias"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Cálculo do intervalo de tempo
    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=== Consumo de tráfego nos últimos {days} dias ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} requisições)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nTotal no período: {total:.2f} GB")
        
        return data
    else:
        print(f"Erro {response.status_code}: {response.text}")
        return None

# Obtenção de estatísticas por uma semana
history = get_traffic_history(7)

Monitoramento de estatísticas por proxies individuais

def get_proxy_statistics(proxy_id):
    """Obtenção de estatísticas de um proxy específico"""
    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=== Estatísticas do proxy {proxy_id} ===")
        print(f"Endereço IP: {data['ip_address']}")
        print(f"País: {data['country']}")
        print(f"Tipo: {data['proxy_type']}")
        print(f"Status: {data['status']}")
        print(f"Tráfego utilizado: {data['traffic_used_mb']:.2f} MB")
        print(f"Quantidade de requisições: {data['total_requests']}")
        print(f"Última atividade: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} não encontrado")
        return None

def get_all_proxies_stats():
    """Obtenção de estatísticas de todos os proxies"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Primeiro obtemos a lista de todos os proxies
    response = requests.get(
        f'{BASE_URL}/proxies/list',
        headers=headers,
        timeout=10
    )
    
    if response.status_code == 200:
        proxies = response.json()['proxies']
        
        print(f"\n=== Estatísticas de {len(proxies)} proxies ===\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=== Consumo total de tráfego: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Erro ao obter a lista de proxies")
        return None

# Obtenção de estatísticas de todos os proxies
all_stats = get_all_proxies_stats()

Esses exemplos mostram o trabalho básico com a API. Para sistemas de produção, adicione tratamento de erros, lógica de repetição em caso de falhas de rede e cache de resultados para não exceder os rate limits do provedor.

Exemplos de código em Node.js para monitoramento de tráfego

Node.js é excelente para criar microsserviços de monitoramento que funcionam em segundo plano e enviam notificações em eventos críticos. Usamos a biblioteca axios para requisições HTTP.

Classe básica para trabalhar com a API de 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('Erro ao obter saldo:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Erro ao obter estatísticas:', 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('Erro ao obter histórico de tráfego:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Erro ao obter estatísticas do proxy ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Monitoramento automático com notificações

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 - aviso
      trafficCritical: 5,  // GB - nível crítico
      balanceWarning: 50   // USD - aviso de saldo
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Verificando estatísticas...`);
      console.log(`Saldo: $${balance.balance.toFixed(2)}`);
      console.log(`Saldo de tráfego: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Verificação de limites críticos
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `CRITICAMENTE POUCO TRÁFEGO: restam ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Pouco tráfego: restam ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

      if (balance.balance <= this.thresholds.balanceWarning) {
        alerts.push({
          level: 'warning',
          message: `Saldo baixo: $${balance.balance.toFixed(2)}`
        });
      }

      // Envio de notificações
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('Erro de monitoramento:', error);
      await this.sendErrorNotification(error);
    }
  }

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  ATENÇÃO! Problemas detectados:');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // Envio de email (configure 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 = `
      Problemas detectados com o proxy:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Estatísticas atuais:
      - Saldo: $${balance.balance.toFixed(2)}
      - Saldo de tráfego: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Utilizado: ${balance.traffic_used_gb.toFixed(2)} GB
      - Proxies ativos: ${balance.active_proxies}
      
      Recomenda-se reabastecer o saldo ou reduzir a carga.
    `;

    await transporter.sendMail({
      from: process.env.ALERT_FROM_EMAIL,
      to: process.env.ALERT_TO_EMAIL,
      subject: '⚠️ Aviso de proxy',
      text: emailBody
    });
  }

  start() {
    console.log(`Iniciando monitoramento de proxy (verificação a cada ${this.checkInterval / 60000} minutos)`);
    
    // Primeira verificação imediatamente
    this.checkAndNotify();
    
    // Verificações periódicas
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Início do monitoramento
const monitor = new ProxyMonitor(15); // verificação a cada 15 minutos
monitor.start();

Este código cria um serviço em segundo plano que verifica as estatísticas a cada 15 minutos e envia notificações por email ao atingir limites críticos. Para proxies móveis, que geralmente são mais caros que os residenciais, esse monitoramento é especialmente importante para controlar os gastos.

Exemplos de requisições via cURL

cURL é uma ferramenta versátil para testar APIs a partir da linha de comando. É útil para verificar rapidamente endpoints e depurar integrações.

Obtenção do saldo

# Requisição básica de saldo
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Com formatação bonita do JSON (via jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Extraindo um campo específico
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Obtenção de estatísticas por período

# Estatísticas dos últimos 7 dias
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'

# Estatísticas por um tipo específico de proxy
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Obtenção da lista de proxies ativos

# Lista de todos os proxies ativos
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}'

# Contagem do número de proxies ativos
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Script Bash para verificação automática

#!/bin/bash

# Configuração
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - limite de aviso

# Obtenção de estatísticas
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

# Análise do JSON
traffic_remaining=$(echo "$response" | jq -r '.traffic_remaining_gb')
balance=$(echo "$response" | jq -r '.balance')
active_proxies=$(echo "$response" | jq -r '.active_proxies')

# Exibição das estatísticas
echo "=== Estatísticas do proxy $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Saldo de tráfego: ${traffic_remaining} GB"
echo "Saldo: \$${balance}"
echo "Proxies ativos: ${active_proxies}"

# Verificação dos limites
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  ATENÇÃO: Pouco tráfego! Restam ${traffic_remaining} GB"
  
  # Envio de notificação (por exemplo, via Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Pouco tráfego do proxy: ${traffic_remaining} GB"
fi

Salve este script como check_proxy_stats.sh, dê permissões de execução (chmod +x check_proxy_stats.sh) e adicione ao cron para execução automática a cada hora:

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

Automatização do monitoramento e notificações

A verificação manual das estatísticas é ineficaz — é necessária a automação com notificações inteligentes. Vamos considerar um sistema completo de monitoramento com integrações.

Integração com Telegram para notificações

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'):
        """Envio de mensagem para o 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"Erro ao enviar para o Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Monitoramento com notificações no Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Formatação da mensagem
        message = f"""
📊 *Estatísticas do Proxy* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Saldo: ${balance['balance']:.2f}
📈 Utilizado: {balance['traffic_used_gb']:.2f} GB
📉 Restante: {balance['traffic_remaining_gb']:.2f} GB
🔌 Proxies ativos: {balance['active_proxies']}
        """
        
        # Verificação de limites críticos
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *CRITICAMENTE POUCO TRÁFEGO!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Recomenda-se reabastecer o tráfego"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Erro no monitoramento do proxy*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Início do monitoramento
monitor_proxy_with_telegram()

Integração com 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'):
        """Envio de notificação para o Slack"""
        color = {
            'info': '#36a64f',
            'warning': '#ff9900',
            'critical': '#ff0000'
        }.get(level, '#cccccc')
        
        payload = {
            'attachments': [{
                'color': color,
                'title': title,
                'text': message,
                'footer': 'Monitor de Proxy',
                '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"Erro ao enviar para o Slack: {e}")
            return False

def check_proxy_health():
    """Verificação da saúde do proxy com notificações"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Análise do estado
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Detectados {len(offline_proxies)} proxies inativos:\n"
        for proxy in offline_proxies[:5]:  # primeiros 5
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Proxies Inativos',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Criticamente pouco tráfego!',
            f"Restam {balance['traffic_remaining_gb']:.2f} GB. "
            f"Saldo: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Configuração de recarga automática

Alguns provedores permitem, através da API, não apenas obter estatísticas, mas também recarregar automaticamente o saldo ao atingir um limite:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Recarregamento automático em caso de saldo baixo"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Tráfego abaixo do limite ({threshold_gb} GB), iniciando recarga...")
        
        # Requisição de recarga via 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"✅ Saldo recarregado em ${topup_amount_usd}")
            
            # Envio de notificação
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Recarregamento automático\n\n"
                f"Valor: ${topup_amount_usd}\n"
                f"Tráfego antes: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Motivo: limite de {threshold_gb} GB atingido"
            )
        else:
            print(f"❌ Erro ao recarregar: {topup_response.text}")
    else:
        print(f"Tráfego suficiente: {balance['traffic_remaining_gb']:.2f} GB")

# Início da verificação (pode ser adicionada ao cron)
auto_topup_if_needed()

Criação do seu próprio dashboard de estatísticas

Para visualizar dados da API, você pode criar um dashboard web com gráficos de consumo de tráfego, distribuição por países e tipos de proxies. Vamos considerar um exemplo simples em Flask + Chart.js.

Backend em 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):
        """Obtenção de todos os dados para o dashboard"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Saldo e estatísticas gerais
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Histórico dos últimos 30 dias
        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()
        
        # Lista de proxies
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Agregação de dados
        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  # em 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():
    """Página principal do dashboard"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """Endpoint da API para obtenção de estatísticas"""
    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 com gráficos (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Dashboard de Estatísticas de 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>📊 Dashboard de Estatísticas de Proxy</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Saldo</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Saldo de tráfego</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Utilizado</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Proxies ativos</div>
      <div class="stat-value" id="active-proxies">-</div>
    </div>
  </div>

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

  <script>
    const ctx = document.getElementById('trafficChart').getContext('2d');
    const trafficChart = new Chart(ctx, {
      type: 'line',
      data: {
        labels: [],
        datasets: [{
          label: 'Tráfego Utilizado (GB)',
          data: [],
          borderColor: 'rgba(75, 192, 192, 1)',
          borderWidth: 2,
          fill: false
        }]
      },
      options: {
        responsive: true,
        scales: {
          y: {
            beginAtZero: true
          }
        }
      }
    });

    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 history = data.history;
      history.forEach(day => {
        trafficChart.data.labels.push(day.date);
        trafficChart.data.datasets[0].data.push(day.traffic_gb);
      });
      trafficChart.update();
    }

    fetchStats();
    setInterval(fetchStats, 60000); // Atualiza a cada 60 segundos
  </script>
</body>
</html>

Conclusão

A automação do monitoramento e da obtenção de estatísticas de proxies é essencial para otimizar o uso e evitar custos desnecessários. Com as ferramentas e exemplos apresentados neste guia, você pode implementar um sistema robusto para gerenciar seus proxies de forma eficiente.