Comment obtenir des statistiques d'utilisation des proxies via API : automatisation du suivi du trafic

Si vous travaillez avec un grand nombre de proxies — pour l'arbitrage, le scraping ou le multi-comptes — le contrôle manuel de la consommation de trafic devient un cauchemar. L'API des fournisseurs de proxies permet d'automatiser l'obtention de statistiques : solde de trafic, sessions actives, consommation par adresses IP et historique d'utilisation. Dans ce guide, nous examinerons comment intégrer l'API pour le suivi des statistiques avec des exemples de code en Python, Node.js et cURL.

Pourquoi automatiser les statistiques des proxies

Lorsque vous gérez 10 à 50 proxies pour différents projets, la vérification manuelle du solde et de la consommation de trafic via le tableau de bord du fournisseur devient inefficace. L'API résout plusieurs problèmes critiques :

Pour les arbitragistes qui lancent des publicités via de nombreux comptes, il est crucial de savoir quels proxies sont actifs et combien de trafic reste — un blocage soudain dû à une limite atteinte peut coûter des milliers de dollars de profits perdus. Pour les agences SMM, gérant des comptes clients sur Instagram ou TikTok, l'automatisation permet d'émettre des factures précises pour l'utilisation des proxies.

Les scrapers de marketplaces (Wildberries, Ozon, Avito) peuvent automatiquement basculer sur des proxies de secours lorsque la limite des principaux est atteinte. L'API permet de construire des systèmes résilients qui fonctionnent 24/7 sans intervention manuelle.

Principes de base de l'utilisation des API des fournisseurs de proxies

La plupart des fournisseurs de proxies modernes offrent une API RESTful pour gérer le service. L'API fonctionne selon un schéma standard : vous envoyez une requête HTTP à un endpoint spécifique avec des paramètres d'authentification, le serveur renvoie un JSON avec les données.

La structure typique de la réponse JSON d'un fournisseur de proxies ressemble à ceci :

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

Lors de l'utilisation de l'API, il est important de prendre en compte les limites de taux. La plupart des fournisseurs autorisent 60 à 300 requêtes par minute. Pour le suivi des statistiques, cela est plus que suffisant — généralement, les requêtes sont effectuées toutes les 5 à 15 minutes.

Authentification et obtention de la clé API

La première étape pour travailler avec l'API consiste à obtenir une clé d'authentification. Le processus varie selon les fournisseurs, mais la logique générale est la même :

Il existe deux méthodes principales d'authentification dans les API des fournisseurs de proxies :

Important : ne stockez jamais les clés API dans le code qui se retrouve dans un dépôt Git. Utilisez des variables d'environnement (fichiers .env) ou des gestionnaires de secrets (AWS Secrets Manager, HashiCorp Vault). Si la clé est compromise — révoquez-la immédiatement dans le tableau de bord et générez une nouvelle clé.

Principaux endpoints pour obtenir des statistiques

Bien que chaque fournisseur ait sa propre structure API, la plupart fournissent un ensemble standard d'endpoints pour obtenir des statistiques. Examinons les méthodes typiques :

Les paramètres des requêtes incluent généralement des plages de dates et des filtres :

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

Pour travailler avec des proxies résidentiels, l'endpoint pour obtenir des statistiques sur les sessions est particulièrement important, car ils utilisent souvent la rotation des IP. L'API permet de suivre combien d'IP uniques ont été utilisées sur une période et quel volume de trafic a transité par chaque session.

Exemples de code en Python pour obtenir des statistiques

Python est le langage le plus populaire pour automatiser le travail avec les proxies grâce à la bibliothèque requests. Examinons des exemples pratiques pour obtenir des statistiques via l'API.

Requête de base pour le solde et le trafic

import requests
import os
from datetime import datetime

# Identifiants API depuis les variables d'environnement
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Obtenir le solde et les statistiques globales"""
    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"=== Statistiques des proxies au {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Solde : ${data['balance']:.2f}")
        print(f"Trafic utilisé : {data['traffic_used_gb']:.2f} GB")
        print(f"Reste de trafic : {data['traffic_remaining_gb']:.2f} GB")
        print(f"Proxies actifs : {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Erreur lors de la requête : {e}")
        return None

# Appel de la fonction
stats = get_balance_statistics()

Obtenir des statistiques détaillées sur une période

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Obtenir l'historique de la consommation de trafic sur N jours"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Calcul de la plage de dates
    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=== Consommation de trafic au cours des {days} derniers jours ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} requêtes)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nTotal pour la période : {total:.2f} GB")
        
        return data
    else:
        print(f"Erreur {response.status_code}: {response.text}")
        return None

# Obtenir des statistiques pour une semaine
history = get_traffic_history(7)

Suivi des statistiques par proxy individuel

def get_proxy_statistics(proxy_id):
    """Obtenir des statistiques pour un proxy spécifique"""
    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=== Statistiques du proxy {proxy_id} ===")
        print(f"Adresse IP : {data['ip_address']}")
        print(f"Pays : {data['country']}")
        print(f"Type : {data['proxy_type']}")
        print(f"Statut : {data['status']}")
        print(f"Trafic utilisé : {data['traffic_used_mb']:.2f} MB")
        print(f"Nombre de requêtes : {data['total_requests']}")
        print(f"Dernière activité : {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} non trouvé")
        return None

def get_all_proxies_stats():
    """Obtenir des statistiques pour tous les proxies"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # D'abord obtenir la liste de tous les 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=== Statistiques pour {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=== Consommation totale de trafic : {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Erreur lors de l'obtention de la liste des proxies")
        return None

# Obtenir des statistiques pour tous les proxies
all_stats = get_all_proxies_stats()

Ces exemples montrent le fonctionnement de base avec l'API. Pour les systèmes de production, ajoutez une gestion des erreurs, une logique de réessai en cas d'échecs réseau et un cache des résultats pour ne pas dépasser les limites de taux du fournisseur.

Exemples de code en Node.js pour le suivi du trafic

Node.js est idéal pour créer des microservices de suivi qui fonctionnent en arrière-plan et envoient des notifications lors d'événements critiques. Utilisons la bibliothèque axios pour les requêtes HTTP.

Classe de base pour travailler avec l'API des proxies

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('Erreur lors de l\'obtention du solde :', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Erreur lors de l\'obtention des statistiques :', 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('Erreur lors de l\'obtention de l\'historique du trafic :', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Erreur lors de l'obtention des statistiques du proxy ${proxyId} :`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Suivi automatique avec notifications

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 - avertissement
      trafficCritical: 5,  // GB - niveau critique
      balanceWarning: 50   // USD - avertissement de solde
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Vérification des statistiques...`);
      console.log(`Solde : $${balance.balance.toFixed(2)}`);
      console.log(`Reste de trafic : ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Vérification des seuils critiques
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `CRITIQUE : IL RESTE TRÈS PEU DE TRAFIC : ${balance.traffic_remaining_gb.toFixed(2)} GB !`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Peu de trafic : il reste ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

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

      // Envoi des notifications
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

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

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  ATTENTION ! Problèmes détectés :');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // Envoi d'email (configurer 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 = `
      Problèmes détectés avec les proxies :
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Statistiques actuelles :
      - Solde : $${balance.balance.toFixed(2)}
      - Reste de trafic : ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Utilisé : ${balance.traffic_used_gb.toFixed(2)} GB
      - Proxies actifs : ${balance.active_proxies}
      
      Il est recommandé de recharger le solde ou de réduire la charge.
    `;

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

  start() {
    console.log(`Démarrage du suivi des proxies (vérification toutes les ${this.checkInterval / 60000} minutes)`);
    
    // Première vérification immédiatement
    this.checkAndNotify();
    
    // Vérifications périodiques
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Démarrage du suivi
const monitor = new ProxyMonitor(15); // vérification toutes les 15 minutes
monitor.start();

Ce code crée un service en arrière-plan qui vérifie les statistiques toutes les 15 minutes et envoie des notifications par email lorsque des seuils critiques sont atteints. Pour les proxies mobiles, qui sont généralement plus chers que les résidentiels, un tel suivi est particulièrement important pour contrôler les dépenses.

Exemples de requêtes via cURL

cURL est un outil universel pour tester les API depuis la ligne de commande. Il est utile pour vérifier rapidement les endpoints et déboguer les intégrations.

Obtenir le solde

# Requête de base pour le solde
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Avec un formatage JSON agréable (via jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Extraction d'un champ spécifique
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Obtenir des statistiques sur une période

# Statistiques des 7 derniers jours
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'

# Statistiques pour un type de proxy spécifique
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Obtenir la liste des proxies actifs

# Liste de tous les proxies actifs
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}'

# Compter le nombre de proxies actifs
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Script Bash pour vérification automatique

#!/bin/bash

# Configuration
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - seuil d'avertissement

# Obtenir des statistiques
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

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

# Affichage des statistiques
echo "=== Statistiques des proxies $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Reste de trafic : ${traffic_remaining} GB"
echo "Solde : \$${balance}"
echo "Proxies actifs : ${active_proxies}"

# Vérification des seuils
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  ATTENTION : Peu de trafic ! Il reste ${traffic_remaining} GB"
  
  # Envoi d'une notification (par exemple, via Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Peu de trafic pour le proxy : ${traffic_remaining} GB"
fi

Enregistrez ce script sous check_proxy_stats.sh, donnez-lui des droits d'exécution (chmod +x check_proxy_stats.sh) et ajoutez-le à cron pour un lancement automatique chaque heure :

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

Automatisation du suivi et des notifications

La vérification manuelle des statistiques est inefficace — l'automatisation avec des notifications intelligentes est nécessaire. Examinons un système complet de suivi avec des intégrations.

Intégration avec Telegram pour les notifications

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'):
        """Envoi d'un message sur 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"Erreur lors de l'envoi sur Telegram : {e}")
            return False

def monitor_proxy_with_telegram():
    """Suivi avec notifications sur Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Formation du message
        message = f"""
📊 *Statistiques des proxies* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Solde : ${balance['balance']:.2f}
📈 Utilisé : {balance['traffic_used_gb']:.2f} GB
📉 Reste : {balance['traffic_remaining_gb']:.2f} GB
🔌 Proxies actifs : {balance['active_proxies']}
        """
        
        # Vérification des seuils critiques
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *CRITIQUE : IL RESTE TRÈS PEU DE TRAFIC !*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Il est recommandé de recharger le trafic"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Erreur de suivi des proxies*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Démarrage du suivi
monitor_proxy_with_telegram()

Intégration avec 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'):
        """Envoi d'une notification sur 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"Erreur lors de l'envoi sur Slack : {e}")
            return False

def check_proxy_health():
    """Vérification de la santé des proxies avec notifications"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Analyse de l'état
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Détection de {len(offline_proxies)} proxies inactifs :\n"
        for proxy in offline_proxies[:5]:  # les 5 premiers
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Proxies inactifs',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Critiquement peu de trafic !',
            f"Il reste {balance['traffic_remaining_gb']:.2f} GB. "
            f"Solde : ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Configuration du rechargement automatique

Certains fournisseurs permettent via l'API non seulement d'obtenir des statistiques, mais aussi de recharger automatiquement le solde lorsqu'un seuil est atteint :

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Rechargement automatique en cas de solde bas"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Trafic en dessous du seuil ({threshold_gb} GB), lancement du rechargement...")
        
        # Requête de rechargement via l'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"✅ Solde rechargé de ${topup_amount_usd}")
            
            # Envoi d'une notification
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Rechargement automatique\n\n"
                f"Montant : ${topup_amount_usd}\n"
                f"Trafic avant : {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Raison : seuil atteint de {threshold_gb} GB"
            )
        else:
            print(f"❌ Erreur de rechargement : {topup_response.text}")
    else:
        print(f"Trafic suffisant : {balance['traffic_remaining_gb']:.2f} GB")

# Démarrer la vérification (peut être ajouté à cron)
auto_topup_if_needed()

Création de votre propre tableau de bord de statistiques

Pour visualiser les données de l'API, vous pouvez créer un tableau de bord web avec des graphiques de consommation de trafic, de répartition par pays et de types de proxies. Examinons un exemple simple avec Flask + Chart.js.

Backend avec 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):
        """Obtenir toutes les données pour le tableau de bord"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Solde et statistiques globales
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Historique des 30 derniers jours
        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()
        
        # Liste des proxies
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Agrégation des données
        traffic_by_country = {}
        traffic_by_type = {}
        
        for proxy in proxies.get('proxies', []):
            country = proxy.get('country', 'Inconnu')
            proxy_type = proxy.get('proxy_type', 'Inconnu')
            traffic = proxy.get('traffic_used_mb', 0) / 1024  # en 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():
    """Page d'accueil du tableau de bord"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """Endpoint API pour obtenir des statistiques"""
    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 avec graphiques (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Tableau de bord des statistiques des proxies</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>📊 Tableau de bord des statistiques des proxies</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Solde</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Reste de trafic</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Utilisé</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Proxies actifs</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(stat => stat.date);
      const trafficData = data.history.map(stat => stat.traffic_gb);

      const ctx = document.getElementById('trafficChart').getContext('2d');
      new Chart(ctx, {
        type: 'line',
        data: {
          labels: labels,
          datasets: [{
            label: 'Trafic utilisé (GB)',
            data: trafficData,
            borderColor: 'rgba(38, 99, 235, 1)',
            backgroundColor: 'rgba(38, 99, 235, 0.2)',
            fill: true
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

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