Как получать статистику использования прокси через API: автоматизация учета трафика

Если вы работаете с большим количеством прокси — для арбитража, парсинга или мультиаккаунтинга — ручной контроль расхода трафика превращается в кошмар. API прокси-провайдеров позволяет автоматизировать получение статистики: остаток трафика, активные сессии, расход по IP-адресам и история использования. В этом руководстве разберем, как интегрировать API для учета статистики на примерах кода на Python, Node.js и cURL.

Зачем нужна автоматизация статистики прокси

Когда вы управляете 10-50 прокси для разных проектов, ручная проверка баланса и расхода трафика через личный кабинет провайдера становится неэффективной. API решает несколько критических задач:

Для арбитражников, которые запускают рекламу через множество аккаунтов, критически важно знать, какие прокси активны и сколько трафика осталось — внезапная блокировка из-за исчерпанного лимита может стоить тысяч долларов упущенной прибыли. Для SMM-агентств, управляющих клиентскими аккаунтами в Instagram или TikTok, автоматизация позволяет выставлять точные счета за использование прокси.

Парсеры маркетплейсов (Wildberries, Ozon, Авито) могут автоматически переключаться на резервные прокси при исчерпании лимита на основных. API дает возможность строить отказоустойчивые системы, которые работают 24/7 без ручного вмешательства.

Основы работы с API прокси-провайдеров

Большинство современных прокси-провайдеров предоставляют RESTful API для управления сервисом. API работает по стандартной схеме: вы отправляете HTTP-запрос на определенный эндпоинт с параметрами аутентификации, сервер возвращает JSON с данными.

Типичная структура JSON-ответа от API прокси-провайдера выглядит так:

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

При работе с API важно учитывать rate limits (ограничения на количество запросов). Большинство провайдеров разрешают 60-300 запросов в минуту. Для мониторинга статистики этого более чем достаточно — обычно запросы делаются раз в 5-15 минут.

Аутентификация и получение API-ключа

Первый шаг работы с API — получение ключа аутентификации. У разных провайдеров процесс отличается, но общая логика одинакова:

Существует два основных метода аутентификации в API прокси-провайдеров:

Важно: никогда не храните API-ключи в коде, который попадает в Git-репозиторий. Используйте переменные окружения (.env файлы) или менеджеры секретов (AWS Secrets Manager, HashiCorp Vault). Если ключ утек — немедленно отзовите его в личном кабинете и сгенерируйте новый.

Основные эндпоинты для получения статистики

Хотя у каждого провайдера своя структура API, большинство предоставляют стандартный набор эндпоинтов для получения статистики. Рассмотрим типичные методы:

Параметры запросов обычно включают временные диапазоны и фильтры:

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

Для работы с резидентными прокси особенно важен эндпоинт получения статистики по сессиям, так как они часто используют ротацию IP. API позволяет отслеживать, сколько уникальных IP было использовано за период и какой объем трафика прошел через каждую сессию.

Примеры кода на Python для получения статистики

Python — самый популярный язык для автоматизации работы с прокси благодаря библиотеке requests. Рассмотрим практические примеры получения статистики через API.

Базовый запрос баланса и трафика

import requests
import os
from datetime import datetime

# API credentials из переменных окружения
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Получение баланса и общей статистики"""
    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"=== Статистика прокси на {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Баланс: ${data['balance']:.2f}")
        print(f"Использовано трафика: {data['traffic_used_gb']:.2f} GB")
        print(f"Остаток трафика: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Активных прокси: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Ошибка при запросе: {e}")
        return None

# Вызов функции
stats = get_balance_statistics()

Получение детальной статистики по периоду

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Получение истории расхода трафика за N дней"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Расчет временного диапазона
    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=== Расход трафика за последние {days} дней ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} запросов)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nИтого за период: {total:.2f} GB")
        
        return data
    else:
        print(f"Ошибка {response.status_code}: {response.text}")
        return None

# Получение статистики за неделю
history = get_traffic_history(7)

Мониторинг статистики по отдельным прокси

def get_proxy_statistics(proxy_id):
    """Получение статистики по конкретному прокси"""
    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=== Статистика прокси {proxy_id} ===")
        print(f"IP адрес: {data['ip_address']}")
        print(f"Страна: {data['country']}")
        print(f"Тип: {data['proxy_type']}")
        print(f"Статус: {data['status']}")
        print(f"Трафик использовано: {data['traffic_used_mb']:.2f} MB")
        print(f"Количество запросов: {data['total_requests']}")
        print(f"Последняя активность: {data['last_activity']}")
        
        return data
    else:
        print(f"Прокси {proxy_id} не найден")
        return None

def get_all_proxies_stats():
    """Получение статистики по всем прокси"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Сначала получаем список всех прокси
    response = requests.get(
        f'{BASE_URL}/proxies/list',
        headers=headers,
        timeout=10
    )
    
    if response.status_code == 200:
        proxies = response.json()['proxies']
        
        print(f"\n=== Статистика по {len(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=== Общий расход трафика: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Ошибка получения списка прокси")
        return None

# Получение статистики по всем прокси
all_stats = get_all_proxies_stats()

Эти примеры показывают базовую работу с API. Для продакшн-систем добавьте обработку ошибок, retry-логику при сбоях сети и кеширование результатов, чтобы не превысить rate limits провайдера.

Примеры кода на Node.js для мониторинга трафика

Node.js отлично подходит для создания микросервисов мониторинга, которые работают в фоне и отправляют уведомления при критических событиях. Используем библиотеку axios для HTTP-запросов.

Базовый класс для работы с 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('Ошибка получения баланса:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Ошибка получения статистики:', 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('Ошибка получения истории трафика:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Ошибка получения статистики прокси ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Автоматический мониторинг с уведомлениями

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 - предупреждение
      trafficCritical: 5,  // GB - критический уровень
      balanceWarning: 50   // USD - предупреждение о балансе
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Проверка статистики...`);
      console.log(`Баланс: $${balance.balance.toFixed(2)}`);
      console.log(`Остаток трафика: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Проверка критических порогов
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `КРИТИЧЕСКИ МАЛО ТРАФИКА: осталось ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Мало трафика: осталось ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

      if (balance.balance <= this.thresholds.balanceWarning) {
        alerts.push({
          level: 'warning',
          message: `Низкий баланс: $${balance.balance.toFixed(2)}`
        });
      }

      // Отправка уведомлений
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('Ошибка мониторинга:', error);
      await this.sendErrorNotification(error);
    }
  }

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  ВНИМАНИЕ! Обнаружены проблемы:');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // Отправка email (настройте 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 = `
      Обнаружены проблемы с прокси:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Текущая статистика:
      - Баланс: $${balance.balance.toFixed(2)}
      - Остаток трафика: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Использовано: ${balance.traffic_used_gb.toFixed(2)} GB
      - Активных прокси: ${balance.active_proxies}
      
      Рекомендуется пополнить баланс или уменьшить нагрузку.
    `;

    await transporter.sendMail({
      from: process.env.ALERT_FROM_EMAIL,
      to: process.env.ALERT_TO_EMAIL,
      subject: '⚠️ Предупреждение о прокси',
      text: emailBody
    });
  }

  start() {
    console.log(`Запуск мониторинга прокси (проверка каждые ${this.checkInterval / 60000} минут)`);
    
    // Первая проверка сразу
    this.checkAndNotify();
    
    // Периодические проверки
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Запуск мониторинга
const monitor = new ProxyMonitor(15); // проверка каждые 15 минут
monitor.start();

Этот код создает фоновый сервис, который каждые 15 минут проверяет статистику и отправляет email-уведомления при достижении критических порогов. Для мобильных прокси, которые обычно дороже резидентных, такой мониторинг особенно важен для контроля расходов.

Примеры запросов через cURL

cURL — универсальный инструмент для тестирования API из командной строки. Полезен для быстрой проверки эндпоинтов и отладки интеграций.

Получение баланса

# Базовый запрос баланса
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# С красивым форматированием JSON (через jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Извлечение конкретного поля
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Получение статистики за период

# Статистика за последние 7 дней
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'

# Статистика по конкретному типу прокси
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Получение списка активных прокси

# Список всех активных прокси
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}'

# Подсчет количества активных прокси
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Bash-скрипт для автоматической проверки

#!/bin/bash

# Конфигурация
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - порог предупреждения

# Получение статистики
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

# Парсинг JSON
traffic_remaining=$(echo "$response" | jq -r '.traffic_remaining_gb')
balance=$(echo "$response" | jq -r '.balance')
active_proxies=$(echo "$response" | jq -r '.active_proxies')

# Вывод статистики
echo "=== Статистика прокси $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Остаток трафика: ${traffic_remaining} GB"
echo "Баланс: \$${balance}"
echo "Активных прокси: ${active_proxies}"

# Проверка порогов
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  ВНИМАНИЕ: Мало трафика! Осталось ${traffic_remaining} GB"
  
  # Отправка уведомления (например, через Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Мало трафика прокси: ${traffic_remaining} GB"
fi

Сохраните этот скрипт как check_proxy_stats.sh, дайте права на выполнение (chmod +x check_proxy_stats.sh) и добавьте в cron для автоматического запуска каждый час:

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

Автоматизация мониторинга и уведомлений

Ручная проверка статистики неэффективна — нужна автоматизация с умными уведомлениями. Рассмотрим полноценную систему мониторинга с интеграциями.

Интеграция с Telegram для уведомлений

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'):
        """Отправка сообщения в 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"Ошибка отправки в Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Мониторинг с уведомлениями в Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Формирование сообщения
        message = f"""
📊 *Статистика прокси* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Баланс: ${balance['balance']:.2f}
📈 Использовано: {balance['traffic_used_gb']:.2f} GB
📉 Осталось: {balance['traffic_remaining_gb']:.2f} GB
🔌 Активных прокси: {balance['active_proxies']}
        """
        
        # Проверка критических порогов
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *КРИТИЧЕСКИ МАЛО ТРАФИКА!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Рекомендуется пополнить трафик"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Ошибка мониторинга прокси*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Запуск мониторинга
monitor_proxy_with_telegram()

Интеграция с 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'):
        """Отправка уведомления в 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"Ошибка отправки в Slack: {e}")
            return False

def check_proxy_health():
    """Проверка здоровья прокси с уведомлениями"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Анализ состояния
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Обнаружено {len(offline_proxies)} неактивных прокси:\n"
        for proxy in offline_proxies[:5]:  # первые 5
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Неактивные прокси',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Критически мало трафика!',
            f"Осталось {balance['traffic_remaining_gb']:.2f} GB. "
            f"Баланс: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Настройка автоматического пополнения

Некоторые провайдеры позволяют через API не только получать статистику, но и автоматически пополнять баланс при достижении порога:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Автоматическое пополнение при низком балансе"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Трафик ниже порога ({threshold_gb} GB), запуск пополнения...")
        
        # Запрос на пополнение через 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"✅ Баланс пополнен на ${topup_amount_usd}")
            
            # Отправка уведомления
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Автоматическое пополнение\n\n"
                f"Сумма: ${topup_amount_usd}\n"
                f"Было трафика: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Причина: достигнут порог {threshold_gb} GB"
            )
        else:
            print(f"❌ Ошибка пополнения: {topup_response.text}")
    else:
        print(f"Трафика достаточно: {balance['traffic_remaining_gb']:.2f} GB")

# Запуск проверки (можно добавить в cron)
auto_topup_if_needed()

Создание собственного дашборда статистики

Для визуализации данных из API можно создать веб-дашборд с графиками расхода трафика, распределения по странам и типам прокси. Рассмотрим простой пример на Flask + Chart.js.

Backend на 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):
        """Получение всех данных для дашборда"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Баланс и общая статистика
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # История за последние 30 дней
        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()
        
        # Список прокси
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Агрегация данных
        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  # в 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():
    """Главная страница дашборда"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """API эндпоинт для получения статистики"""
    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 с графиками (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Proxy Statistics 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 Statistics Dashboard</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Баланс</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Остаток трафика</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Использовано&