Come ottenere statistiche sull'uso dei proxy tramite API: automazione del monitoraggio del traffico

Se lavori con un gran numero di proxy — per arbitraggio, scraping o multi-accounting — il controllo manuale del consumo di traffico diventa un incubo. Le API dei fornitori di proxy consentono di automatizzare l'ottenimento delle statistiche: saldo del traffico, sessioni attive, consumo per indirizzi IP e cronologia d'uso. In questa guida vedremo come integrare le API per la gestione delle statistiche con esempi di codice in Python, Node.js e cURL.

Perché è necessaria l'automazione delle statistiche dei proxy

Quando gestisci 10-50 proxy per diversi progetti, il controllo manuale del saldo e del consumo di traffico tramite il pannello del fornitore diventa inefficace. Le API risolvono diverse questioni critiche:

Per gli arbitraggisti che lanciano pubblicità tramite molti account, è fondamentale sapere quali proxy sono attivi e quanto traffico è rimasto — un blocco improvviso a causa di un limite esaurito può costare migliaia di dollari di profitto perso. Per le agenzie SMM che gestiscono account clienti su Instagram o TikTok, l'automazione consente di emettere fatture precise per l'uso dei proxy.

Gli scraper di marketplace (Wildberries, Ozon, Avito) possono passare automaticamente a proxy di riserva quando il limite sui principali è esaurito. Le API consentono di costruire sistemi a prova di errore che funzionano 24/7 senza intervento manuale.

Fondamenti dell'uso delle API dei fornitori di proxy

La maggior parte dei moderni fornitori di proxy offre API RESTful per gestire il servizio. Le API funzionano secondo uno schema standard: invii una richiesta HTTP a un determinato endpoint con i parametri di autenticazione, il server restituisce un JSON con i dati.

Una tipica struttura della risposta JSON da un'API di un fornitore di proxy appare così:

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

Quando si lavora con le API, è importante considerare i rate limits (limiti sul numero di richieste). La maggior parte dei fornitori consente 60-300 richieste al minuto. Per il monitoraggio delle statistiche, questo è più che sufficiente — di solito le richieste vengono effettuate ogni 5-15 minuti.

Autenticazione e ottenimento della chiave API

Il primo passo per lavorare con le API è ottenere una chiave di autenticazione. Il processo varia a seconda dei fornitori, ma la logica generale è la stessa:

Esistono due metodi principali di autenticazione nelle API dei fornitori di proxy:

Importante: non memorizzare mai le chiavi API nel codice che finisce in un repository Git. Utilizza variabili di ambiente (file .env) o gestori di segreti (AWS Secrets Manager, HashiCorp Vault). Se la chiave viene esposta — revocala immediatamente nel pannello e generane una nuova.

Principali endpoint per ottenere statistiche

Anche se ogni fornitore ha la propria struttura API, la maggior parte fornisce un insieme standard di endpoint per ottenere statistiche. Vediamo i metodi tipici:

I parametri delle richieste di solito includono intervalli temporali e filtri:

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

Per lavorare con proxy residenziali è particolarmente importante l'endpoint per ottenere statistiche sulle sessioni, poiché spesso utilizzano la rotazione degli IP. Le API consentono di monitorare quanti IP unici sono stati utilizzati nel periodo e quale volume di traffico è passato attraverso ciascuna sessione.

Esempi di codice in Python per ottenere statistiche

Python è il linguaggio più popolare per l'automazione del lavoro con i proxy grazie alla libreria requests. Vediamo esempi pratici per ottenere statistiche tramite API.

Richiesta base di saldo e traffico

import requests
import os
from datetime import datetime

# Credenziali API dalle variabili d'ambiente
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Ottenere il saldo e le statistiche generali"""
    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"=== Statistiche proxy al {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Saldo: ${data['balance']:.2f}")
        print(f"Traffico utilizzato: {data['traffic_used_gb']:.2f} GB")
        print(f"Saldo del traffico: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Proxy attivi: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Errore nella richiesta: {e}")
        return None

# Chiamata della funzione
stats = get_balance_statistics()

Ottenere statistiche dettagliate per periodo

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Ottenere la cronologia del consumo di traffico per N giorni"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Calcolo dell'intervallo temporale
    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 di traffico negli ultimi {days} giorni ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} richieste)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nTotale per il periodo: {total:.2f} GB")
        
        return data
    else:
        print(f"Errore {response.status_code}: {response.text}")
        return None

# Ottenere statistiche per una settimana
history = get_traffic_history(7)

Monitoraggio delle statistiche per singoli proxy

def get_proxy_statistics(proxy_id):
    """Ottenere statistiche per un proxy specifico"""
    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=== Statistiche proxy {proxy_id} ===")
        print(f"Indirizzo IP: {data['ip_address']}")
        print(f"Paese: {data['country']}")
        print(f"Tipo: {data['proxy_type']}")
        print(f"Stato: {data['status']}")
        print(f"Traffico utilizzato: {data['traffic_used_mb']:.2f} MB")
        print(f"Numero di richieste: {data['total_requests']}")
        print(f"Ultima attività: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} non trovato")
        return None

def get_all_proxies_stats():
    """Ottenere statistiche per tutti i proxy"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Prima otteniamo l'elenco di tutti i 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=== Statistiche per {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=== Consumo totale di traffico: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Errore nell'ottenere l'elenco dei proxy")
        return None

# Ottenere statistiche per tutti i proxy
all_stats = get_all_proxies_stats()

Questi esempi mostrano il funzionamento di base con le API. Per i sistemi di produzione, aggiungi la gestione degli errori, la logica di retry in caso di fallimenti di rete e la memorizzazione dei risultati per non superare i rate limits del fornitore.

Esempi di codice in Node.js per il monitoraggio del traffico

Node.js è ottimo per creare microservizi di monitoraggio che funzionano in background e inviano notifiche in caso di eventi critici. Utilizziamo la libreria axios per le richieste HTTP.

Classe base per lavorare con le API dei 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('Errore nell\'ottenere il saldo:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Errore nell\'ottenere le statistiche:', 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('Errore nell\'ottenere la cronologia del traffico:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Errore nell\'ottenere le statistiche del proxy ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Monitoraggio automatico con notifiche

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 - avviso
      trafficCritical: 5,  // GB - livello critico
      balanceWarning: 50   // USD - avviso sul saldo
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Controllo delle statistiche...`);
      console.log(`Saldo: $${balance.balance.toFixed(2)}`);
      console.log(`Saldo del traffico: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Controllo dei limiti critici
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `CRITICAMENTE POCO TRAFFICO: rimasti ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Poco traffico: rimasti ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

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

      // Invio delle notifiche
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('Errore nel monitoraggio:', error);
      await this.sendErrorNotification(error);
    }
  }

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  ATTENZIONE! Problemi rilevati:');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // Invio email (configura 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 = `
      Problemi rilevati con i proxy:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Statistiche attuali:
      - Saldo: $${balance.balance.toFixed(2)}
      - Saldo del traffico: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Utilizzato: ${balance.traffic_used_gb.toFixed(2)} GB
      - Proxy attivi: ${balance.active_proxies}
      
      Si consiglia di ricaricare il saldo o ridurre il carico.
    `;

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

  start() {
    console.log(`Avvio del monitoraggio dei proxy (controllo ogni ${this.checkInterval / 60000} minuti)`);
    
    // Primo controllo subito
    this.checkAndNotify();
    
    // Controlli periodici
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Avvio del monitoraggio
const monitor = new ProxyMonitor(15); // controllo ogni 15 minuti
monitor.start();

Questo codice crea un servizio in background che controlla le statistiche ogni 15 minuti e invia notifiche email quando si raggiungono soglie critiche. Per proxy mobili, che di solito sono più costosi di quelli residenziali, questo monitoraggio è particolarmente importante per controllare le spese.

Esempi di richieste tramite cURL

cURL è uno strumento versatile per testare le API dalla riga di comando. Utile per un rapido controllo degli endpoint e per il debug delle integrazioni.

Ottenere il saldo

# Richiesta base di saldo
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Con bella formattazione JSON (tramite jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Estrazione di un campo specifico
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Ottenere statistiche per periodo

# Statistiche per gli ultimi 7 giorni
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'

# Statistiche per un tipo specifico di proxy
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Ottenere l'elenco dei proxy attivi

# Elenco di tutti i proxy attivi
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}'

# Conteggio del numero di proxy attivi
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Script Bash per il controllo automatico

#!/bin/bash

# Configurazione
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - soglia di avviso

# Ottenere le statistiche
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

# Parsing JSON
traffic_remaining=$(echo "$response" | jq -r '.traffic_remaining_gb')
balance=$(echo "$response" | jq -r '.balance')
active_proxies=$(echo "$response" | jq -r '.active_proxies')

# Stampa delle statistiche
echo "=== Statistiche proxy $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Saldo del traffico: ${traffic_remaining} GB"
echo "Saldo: \$${balance}"
echo "Proxy attivi: ${active_proxies}"

# Controllo delle soglie
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  ATTENZIONE: Poco traffico! Rimasti ${traffic_remaining} GB"
  
  # Invio di una notifica (ad esempio, tramite Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Poco traffico proxy: ${traffic_remaining} GB"
fi

Salva questo script come check_proxy_stats.sh, dai i permessi di esecuzione (chmod +x check_proxy_stats.sh) e aggiungilo al cron per l'esecuzione automatica ogni ora:

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

Automazione del monitoraggio e delle notifiche

Il controllo manuale delle statistiche è inefficace — è necessaria un'automazione con notifiche intelligenti. Vediamo un sistema di monitoraggio completo con integrazioni.

Integrazione con Telegram per le notifiche

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'):
        """Invio di un messaggio su 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"Errore nell'invio a Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Monitoraggio con notifiche su Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Formazione del messaggio
        message = f"""
📊 *Statistiche proxy* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Saldo: ${balance['balance']:.2f}
📈 Utilizzato: {balance['traffic_used_gb']:.2f} GB
📉 Rimasto: {balance['traffic_remaining_gb']:.2f} GB
🔌 Proxy attivi: {balance['active_proxies']}
        """
        
        # Controllo dei limiti critici
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *CRITICAMENTE POCO TRAFFICO!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Si consiglia di ricaricare il traffico"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Errore nel monitoraggio dei proxy*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Avvio del monitoraggio
monitor_proxy_with_telegram()

Integrazione con 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'):
        """Invio di una notifica su 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"Errore nell'invio a Slack: {e}")
            return False

def check_proxy_health():
    """Controllo della salute dei proxy con notifiche"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Analisi dello stato
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Rilevati {len(offline_proxies)} proxy inattivi:\n"
        for proxy in offline_proxies[:5]:  # primi 5
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Proxy inattivi',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Criticamente poco traffico!',
            f"Rimasti {balance['traffic_remaining_gb']:.2f} GB. "
            f"Saldo: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Impostazione del ricarico automatico

Alcuni fornitori consentono tramite API non solo di ottenere statistiche, ma anche di ricaricare automaticamente il saldo al raggiungimento di una soglia:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Ricarica automatica in caso di saldo basso"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Traffico sotto soglia ({threshold_gb} GB), avvio della ricarica...")
        
        # Richiesta di ricarica tramite 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 ricaricato di ${topup_amount_usd}")
            
            # Invio di una notifica
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Ricarica automatica\n\n"
                f"Importo: ${topup_amount_usd}\n"
                f"Traffico rimasto: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Motivo: raggiunta soglia di {threshold_gb} GB"
            )
        else:
            print(f"❌ Errore nella ricarica: {topup_response.text}")
    else:
        print(f"Traffico sufficiente: {balance['traffic_remaining_gb']:.2f} GB")

# Avvio del controllo (può essere aggiunto al cron)
auto_topup_if_needed()

Creazione di un proprio dashboard di statistiche

Per visualizzare i dati delle API, puoi creare un dashboard web con grafici sul consumo di traffico, distribuzione per paesi e tipi di proxy. Vediamo un semplice esempio su Flask + Chart.js.

Backend su 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):
        """Ottenere tutti i dati per il dashboard"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Saldo e statistiche generali
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Cronologia degli ultimi 30 giorni
        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()
        
        # Elenco dei proxy
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Aggregazione dei dati
        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  # in 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():
    """Pagina principale del dashboard"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """API endpoint per ottenere statistiche"""
    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 con grafici (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Dashboard delle Statistiche 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 delle Statistiche 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 del traffico</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Utilizzato</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Proxy attivi</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 ctx = document.getElementById('trafficChart').getContext('2d');
      const labels = data.history.map(day => day.date);
      const trafficData = data.history.map(day => day.traffic_gb);

      new Chart(ctx, {
        type: 'line',
        data: {
          labels: labels,
          datasets: [{
            label: 'Traffico Utilizzato (GB)',
            data: trafficData,
            borderColor: 'rgba(75, 192, 192, 1)',
            borderWidth: 2,
            fill: false
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

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