Statistik zur Proxy-Nutzung über API abrufen: Automatisierung der Traffic-Erfassung

Wenn Sie mit einer großen Anzahl von Proxys arbeiten – für Arbitrage, Scraping oder Multi-Account-Management – wird die manuelle Kontrolle des Datenverbrauchs zum Albtraum. Die API von Proxy-Anbietern ermöglicht die Automatisierung der Statistikerfassung: verbleibender Datenverbrauch, aktive Sitzungen, Verbrauch nach IP-Adressen und Nutzungshistorie. In diesem Leitfaden werden wir besprechen, wie man die API zur Erfassung von Statistiken mit Beispielcode in Python, Node.js und cURL integriert.

Warum die Automatisierung von Proxy-Statistiken notwendig ist

Wenn Sie 10-50 Proxys für verschiedene Projekte verwalten, wird die manuelle Überprüfung des Kontostands und des Datenverbrauchs über das persönliche Konto des Anbieters ineffektiv. Die API löst mehrere kritische Aufgaben:

Für Arbitrageure, die Werbung über viele Konten schalten, ist es entscheidend zu wissen, welche Proxys aktiv sind und wie viel Daten übrig sind – eine plötzliche Sperrung aufgrund eines erschöpften Limits kann Tausende von Dollar an entgangenen Einnahmen kosten. Für SMM-Agenturen, die Kundenkonten bei Instagram oder TikTok verwalten, ermöglicht die Automatisierung die genaue Abrechnung der Proxy-Nutzung.

Scraper von Marktplätzen (Wildberries, Ozon, Avito) können automatisch auf Backup-Proxys umschalten, wenn das Limit der Hauptproxys erschöpft ist. Die API ermöglicht den Aufbau von ausfallsicheren Systemen, die 24/7 ohne manuelles Eingreifen arbeiten.

Grundlagen der Arbeit mit Proxy-Anbieter-APIs

Die meisten modernen Proxy-Anbieter bieten eine RESTful API zur Verwaltung des Dienstes an. Die API funktioniert nach einem Standardverfahren: Sie senden eine HTTP-Anfrage an einen bestimmten Endpoint mit Authentifizierungsparametern, der Server gibt ein JSON mit Daten zurück.

Eine typische JSON-Antwort von der API eines Proxy-Anbieters sieht so aus:

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

Bei der Arbeit mit der API ist es wichtig, die Rate Limits (Anfragebeschränkungen) zu beachten. Die meisten Anbieter erlauben 60-300 Anfragen pro Minute. Für die Überwachung der Statistiken ist dies mehr als ausreichend – normalerweise werden Anfragen alle 5-15 Minuten gestellt.

Authentifizierung und Erhalt des API-Schlüssels

Der erste Schritt bei der Arbeit mit der API ist der Erhalt eines Authentifizierungsschlüssels. Der Prozess variiert je nach Anbieter, aber die allgemeine Logik ist gleich:

Es gibt zwei Hauptmethoden zur Authentifizierung in den APIs von Proxy-Anbietern:

Wichtig: Speichern Sie API-Schlüssel niemals im Code, der in ein Git-Repository gelangt. Verwenden Sie Umgebungsvariablen (.env-Dateien) oder Geheimnismanager (AWS Secrets Manager, HashiCorp Vault). Wenn der Schlüssel geleakt wird, ziehen Sie ihn sofort in Ihrem persönlichen Konto zurück und generieren Sie einen neuen.

Wichtige Endpoints zur Erfassung von Statistiken

Obwohl jeder Anbieter seine eigene API-Struktur hat, bieten die meisten einen Standard-Satz von Endpoints zur Erfassung von Statistiken an. Lassen Sie uns typische Methoden betrachten:

Die Anfrageparameter umfassen normalerweise Zeiträume und Filter:

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

Für die Arbeit mit residential Proxys ist der Endpoint zur Erfassung von Statistiken über Sitzungen besonders wichtig, da diese häufig IP-Rotation verwenden. Die API ermöglicht es, nachzuvollziehen, wie viele einzigartige IPs über einen Zeitraum verwendet wurden und welches Datenvolumen durch jede Sitzung geflossen ist.

Beispielcode in Python zur Erfassung von Statistiken

Python ist die beliebteste Sprache zur Automatisierung der Arbeit mit Proxys dank der Bibliothek requests. Lassen Sie uns praktische Beispiele zur Erfassung von Statistiken über die API betrachten.

Basisanfrage für Kontostand und Datenverbrauch

import requests
import os
from datetime import datetime

# API-Anmeldeinformationen aus Umgebungsvariablen
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Erfassung von Kontostand und Gesamtstatistik"""
    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"=== Proxy-Statistik am {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Kontostand: ${data['balance']:.2f}")
        print(f"Verbrauchte Daten: {data['traffic_used_gb']:.2f} GB")
        print(f"Verbleibende Daten: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Aktive Proxys: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Fehler bei der Anfrage: {e}")
        return None

# Funktionsaufruf
stats = get_balance_statistics()

Erfassung detaillierter Statistiken über einen Zeitraum

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Erfassung der Datenverbrauchshistorie über N Tage"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Berechnung des Zeitraums
    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=== Datenverbrauch der letzten {days} Tage ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} Anfragen)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nInsgesamt für den Zeitraum: {total:.2f} GB")
        
        return data
    else:
        print(f"Fehler {response.status_code}: {response.text}")
        return None

# Erfassung der Statistiken für eine Woche
history = get_traffic_history(7)

Überwachung der Statistiken für einzelne Proxys

def get_proxy_statistics(proxy_id):
    """Erfassung der Statistiken für einen bestimmten Proxy"""
    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=== Statistiken für Proxy {proxy_id} ===")
        print(f"IP-Adresse: {data['ip_address']}")
        print(f"Land: {data['country']}")
        print(f"Typ: {data['proxy_type']}")
        print(f"Status: {data['status']}")
        print(f"Verbrauchte Daten: {data['traffic_used_mb']:.2f} MB")
        print(f"Anzahl der Anfragen: {data['total_requests']}")
        print(f"Letzte Aktivität: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} nicht gefunden")
        return None

def get_all_proxies_stats():
    """Erfassung der Statistiken für alle Proxys"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Zuerst die Liste aller Proxys abrufen
    response = requests.get(
        f'{BASE_URL}/proxies/list',
        headers=headers,
        timeout=10
    )
    
    if response.status_code == 200:
        proxies = response.json()['proxies']
        
        print(f"\n=== Statistiken für {len(proxies)} Proxys ===\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=== Gesamter Datenverbrauch: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Fehler beim Abrufen der Proxy-Liste")
        return None

# Erfassung der Statistiken für alle Proxys
all_stats = get_all_proxies_stats()

Diese Beispiele zeigen die grundlegende Arbeit mit der API. Für Produktionssysteme fügen Sie eine Fehlerbehandlung, eine Retry-Logik bei Netzwerkfehlern und eine Zwischenspeicherung der Ergebnisse hinzu, um die Rate Limits des Anbieters nicht zu überschreiten.

Beispielcode in Node.js zur Verkehrsüberwachung

Node.js eignet sich hervorragend zur Erstellung von Überwachungs-Mikrodiensten, die im Hintergrund arbeiten und Benachrichtigungen bei kritischen Ereignissen senden. Wir verwenden die Bibliothek axios für HTTP-Anfragen.

Basis-Klasse zur Arbeit mit der Proxy-API

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('Fehler beim Abrufen des Kontostands:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Fehler beim Abrufen der Statistiken:', 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('Fehler beim Abrufen der Verkehrshistorie:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Fehler beim Abrufen der Statistiken für Proxy ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Automatische Überwachung mit Benachrichtigungen

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 - Warnung
      trafficCritical: 5,  // GB - kritischer Pegel
      balanceWarning: 50   // USD - Warnung über den Kontostand
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Überprüfung der Statistiken...`);
      console.log(`Kontostand: $${balance.balance.toFixed(2)}`);
      console.log(`Verbleibende Daten: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Überprüfung kritischer Schwellenwerte
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `Kritisch wenig Daten: verbleibend ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Wenig Daten: verbleibend ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

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

      // Benachrichtigungen senden
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('Überwachungsfehler:', error);
      await this.sendErrorNotification(error);
    }
  }

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

    // E-Mail senden (SMTP konfigurieren)
    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 = `
      Probleme mit Proxys festgestellt:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Aktuelle Statistiken:
      - Kontostand: $${balance.balance.toFixed(2)}
      - Verbleibende Daten: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Verwendet: ${balance.traffic_used_gb.toFixed(2)} GB
      - Aktive Proxys: ${balance.active_proxies}
      
      Es wird empfohlen, das Guthaben aufzufüllen oder die Last zu reduzieren.
    `;

    await transporter.sendMail({
      from: process.env.ALERT_FROM_EMAIL,
      to: process.env.ALERT_TO_EMAIL,
      subject: '⚠️ Proxy-Warnung',
      text: emailBody
    });
  }

  start() {
    console.log(`Start der Proxy-Überwachung (Überprüfung alle ${this.checkInterval / 60000} Minuten)`);
    
    // Erste Überprüfung sofort
    this.checkAndNotify();
    
    // Periodische Überprüfungen
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Start der Überwachung
const monitor = new ProxyMonitor(15); // Überprüfung alle 15 Minuten
monitor.start();

Dieser Code erstellt einen Hintergrunddienst, der alle 15 Minuten die Statistiken überprüft und E-Mail-Benachrichtigungen sendet, wenn kritische Schwellenwerte erreicht werden. Für mobile Proxys, die normalerweise teurer sind als residential Proxys, ist eine solche Überwachung besonders wichtig, um die Ausgaben zu kontrollieren.

Beispielanfragen über cURL

cURL ist ein universelles Tool zum Testen von APIs über die Kommandozeile. Es ist nützlich für schnelle Überprüfungen von Endpoints und zur Fehlersuche bei Integrationen.

Erfassung des Kontostands

# Basisanfrage für den Kontostand
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Mit schöner JSON-Formatierung (über jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Extrahieren eines bestimmten Feldes
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Erfassung von Statistiken über einen Zeitraum

# Statistiken der letzten 7 Tage
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'

# Statistiken für einen bestimmten Proxy-Typ
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Erfassung der Liste aktiver Proxys

# Liste aller aktiven Proxys
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}'

# Zählen der Anzahl aktiver Proxys
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Bash-Skript zur automatischen Überprüfung

#!/bin/bash

# Konfiguration
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - Warnschwelle

# Erfassung der Statistiken
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

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

# Ausgabe der Statistiken
echo "=== Proxy-Statistik $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Verbleibende Daten: ${traffic_remaining} GB"
echo "Kontostand: \$${balance}"
echo "Aktive Proxys: ${active_proxies}"

# Überprüfung der Schwellenwerte
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  ACHTUNG: Wenig Daten! Verbleibend ${traffic_remaining} GB"
  
  # Benachrichtigung senden (z.B. über Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Wenig Daten für Proxy: ${traffic_remaining} GB"
fi

Speichern Sie dieses Skript als check_proxy_stats.sh, geben Sie Ausführungsrechte (chmod +x check_proxy_stats.sh) und fügen Sie es zu cron für die automatische Ausführung jede Stunde hinzu:

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

Automatisierung der Überwachung und Benachrichtigungen

Die manuelle Überprüfung der Statistiken ist ineffektiv – eine Automatisierung mit intelligenten Benachrichtigungen ist erforderlich. Lassen Sie uns ein vollständiges Überwachungssystem mit Integrationen betrachten.

Integration mit Telegram für Benachrichtigungen

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'):
        """Nachricht an Telegram senden"""
        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"Fehler beim Senden an Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Überwachung mit Benachrichtigungen in Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Nachricht erstellen
        message = f"""
📊 *Proxy-Statistik* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Kontostand: ${balance['balance']:.2f}
📈 Verwendet: {balance['traffic_used_gb']:.2f} GB
📉 Verbleibend: {balance['traffic_remaining_gb']:.2f} GB
🔌 Aktive Proxys: {balance['active_proxies']}
        """
        
        # Überprüfung kritischer Schwellenwerte
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *Kritisch wenig Daten!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Es wird empfohlen, den Datenverbrauch aufzufüllen"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Fehler bei der Überwachung der Proxys*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Start der Überwachung
monitor_proxy_with_telegram()

Integration mit 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'):
        """Benachrichtigung an Slack senden"""
        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"Fehler beim Senden an Slack: {e}")
            return False

def check_proxy_health():
    """Überprüfung der Proxy-Gesundheit mit Benachrichtigungen"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Zustand analysieren
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Es wurden {len(offline_proxies)} inaktive Proxys festgestellt:\n"
        for proxy in offline_proxies[:5]:  # die ersten 5
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Inaktive Proxys',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Kritisch wenig Daten!',
            f"Verbleibend {balance['traffic_remaining_gb']:.2f} GB. "
            f"Kontostand: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Einrichtung der automatischen Aufladung

Einige Anbieter ermöglichen es über die API, nicht nur Statistiken abzurufen, sondern auch das Guthaben automatisch aufzuladen, wenn ein Schwellenwert erreicht wird:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Automatische Aufladung bei niedrigem Kontostand"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Datenverbrauch unter dem Schwellenwert ({threshold_gb} GB), Aufladung wird gestartet...")
        
        # Anfrage zur Aufladung über die 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"✅ Guthaben um ${topup_amount_usd} aufgeladen")
            
            # Benachrichtigung senden
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Automatische Aufladung\n\n"
                f"Betrag: ${topup_amount_usd}\n"
                f"Verbleibende Daten: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Grund: Schwellenwert von {threshold_gb} GB erreicht"
            )
        else:
            print(f"❌ Fehler bei der Aufladung: {topup_response.text}")
    else:
        print(f"Genug Daten vorhanden: {balance['traffic_remaining_gb']:.2f} GB")

# Überprüfung starten (kann zu cron hinzugefügt werden)
auto_topup_if_needed()

Erstellung eines eigenen Statistik-Dashboards

Zur Visualisierung der Daten aus der API kann ein Web-Dashboard mit Grafiken zum Datenverbrauch, zur Verteilung nach Ländern und Proxy-Typen erstellt werden. Lassen Sie uns ein einfaches Beispiel mit Flask + Chart.js betrachten.

Backend mit 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):
        """Erfassung aller Daten für das Dashboard"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Kontostand und Gesamtstatistik
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Historie der letzten 30 Tage
        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 der Proxys
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Aggregation der Daten
        traffic_by_country = {}
        traffic_by_type = {}
        
        for proxy in proxies.get('proxies', []):
            country = proxy.get('country', 'Unbekannt')
            proxy_type = proxy.get('proxy_type', 'Unbekannt')
            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():
    """Hauptseite des Dashboards"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """API-Endpoint zur Erfassung von Statistiken"""
    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 mit Grafiken (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Proxy-Statistik Dashboard</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>📊 Proxy-Statistik Dashboard</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Kontostand</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Verbleibende Daten</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Verwendet</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Aktive Proxys</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: [], // Hier die Datenlabels einfügen
        datasets: [{
          label: 'Datenverbrauch',
          data: [], // Hier die Verbrauchsdaten einfügen
          borderColor: 'rgba(75, 192, 192, 1)',
          borderWidth: 2,
          fill: false
        }]
      },
      options: {
        responsive: true,
        scales: {
          y: {
            beginAtZero: true
          }
        }
      }
    });

    // Funktion zum Abrufen der Statistiken
    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;

      // Aktualisieren der Grafiken
      trafficChart.data.labels = data.history.map(stat => stat.date);
      trafficChart.data.datasets[0].data = data.history.map(stat => stat.traffic_gb);
      trafficChart.update();
    }

    fetchStats();
    setInterval(fetchStats, 60000); // Aktualisierung alle 60 Sekunden
  </script>
</body>
</html>

Mit diesem Dashboard können Sie die Proxy-Statistiken in Echtzeit überwachen und visualisieren. Es ist wichtig, die API-Daten regelmäßig abzurufen und die Grafiken entsprechend zu aktualisieren.