Cara Mendapatkan Statistik Penggunaan Proxy Melalui API: Automatisasi Pencatatan Lalu Lintas

Jika Anda bekerja dengan banyak proxy — untuk arbitrase, pengambilan data, atau multi-akun — kontrol manual pengeluaran lalu lintas menjadi mimpi buruk. API penyedia proxy memungkinkan otomatisasi pengambilan statistik: sisa lalu lintas, sesi aktif, pengeluaran berdasarkan alamat IP, dan riwayat penggunaan. Dalam panduan ini, kita akan membahas cara mengintegrasikan API untuk penghitungan statistik dengan contoh kode dalam Python, Node.js, dan cURL.

Mengapa otomatisasi statistik proxy diperlukan

Ketika Anda mengelola 10-50 proxy untuk berbagai proyek, pemeriksaan manual saldo dan pengeluaran lalu lintas melalui akun pribadi penyedia menjadi tidak efisien. API menyelesaikan beberapa tugas kritis:

Bagi para arbitrase yang menjalankan iklan melalui banyak akun, sangat penting untuk mengetahui proxy mana yang aktif dan berapa banyak lalu lintas yang tersisa — pemblokiran mendadak karena batas yang habis dapat mengakibatkan kerugian ribuan dolar. Bagi agensi SMM yang mengelola akun klien di Instagram atau TikTok, otomatisasi memungkinkan penagihan yang akurat untuk penggunaan proxy.

Pengambil data dari marketplace (Wildberries, Ozon, Avito) dapat secara otomatis beralih ke proxy cadangan saat batas pada yang utama habis. API memungkinkan membangun sistem yang tahan banting, yang beroperasi 24/7 tanpa intervensi manual.

Dasar-dasar bekerja dengan API penyedia proxy

Sebagian besar penyedia proxy modern menyediakan API RESTful untuk mengelola layanan. API bekerja dengan skema standar: Anda mengirim permintaan HTTP ke endpoint tertentu dengan parameter autentikasi, server mengembalikan JSON dengan data.

Struktur respons JSON yang tipikal dari API penyedia proxy terlihat seperti ini:

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

Saat bekerja dengan API, penting untuk mempertimbangkan rate limits (batas jumlah permintaan). Sebagian besar penyedia mengizinkan 60-300 permintaan per menit. Untuk memantau statistik, ini lebih dari cukup — biasanya permintaan dilakukan setiap 5-15 menit.

Autentikasi dan mendapatkan kunci API

Langkah pertama dalam bekerja dengan API adalah mendapatkan kunci autentikasi. Prosesnya berbeda-beda di setiap penyedia, tetapi logika umumnya sama:

Ada dua metode utama autentikasi dalam API penyedia proxy:

Penting: jangan pernah menyimpan kunci API dalam kode yang masuk ke repositori Git. Gunakan variabel lingkungan (file .env) atau manajer rahasia (AWS Secrets Manager, HashiCorp Vault). Jika kunci bocor — segera cabut di akun pribadi dan hasilkan yang baru.

Endpoint utama untuk mendapatkan statistik

Meskipun setiap penyedia memiliki struktur API yang berbeda, kebanyakan menyediakan seperangkat endpoint standar untuk mendapatkan statistik. Mari kita lihat metode yang tipikal:

Parameter permintaan biasanya mencakup rentang waktu dan 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

Untuk bekerja dengan proxy residensial, endpoint untuk mendapatkan statistik sesi sangat penting, karena mereka sering menggunakan rotasi IP. API memungkinkan untuk melacak berapa banyak IP unik yang telah digunakan selama periode dan berapa banyak lalu lintas yang telah melewati setiap sesi.

Contoh kode dalam Python untuk mendapatkan statistik

Python adalah bahasa yang paling populer untuk otomatisasi kerja dengan proxy berkat pustaka requests. Mari kita lihat contoh praktis untuk mendapatkan statistik melalui API.

Permintaan dasar untuk saldo dan lalu lintas

import requests
import os
from datetime import datetime

# Kredensial API dari variabel lingkungan
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Mendapatkan saldo dan statistik umum"""
    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"=== Statistik proxy pada {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Saldo: ${data['balance']:.2f}")
        print(f"Lalu lintas yang digunakan: {data['traffic_used_gb']:.2f} GB")
        print(f"Sisa lalu lintas: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Proxy aktif: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"Kesalahan saat permintaan: {e}")
        return None

# Memanggil fungsi
stats = get_balance_statistics()

Mendapatkan statistik rinci berdasarkan periode

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """Mendapatkan riwayat pengeluaran lalu lintas selama N hari"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Menghitung rentang waktu
    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=== Pengeluaran lalu lintas selama {days} hari terakhir ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} permintaan)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nTotal selama periode: {total:.2f} GB")
        
        return data
    else:
        print(f"Kesalahan {response.status_code}: {response.text}")
        return None

# Mendapatkan statistik selama seminggu
history = get_traffic_history(7)

Memantau statistik untuk proxy tertentu

def get_proxy_statistics(proxy_id):
    """Mendapatkan statistik untuk proxy tertentu"""
    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=== Statistik proxy {proxy_id} ===")
        print(f"Alamat IP: {data['ip_address']}")
        print(f"Negara: {data['country']}")
        print(f"Tipe: {data['proxy_type']}")
        print(f"Status: {data['status']}")
        print(f"Lalu lintas digunakan: {data['traffic_used_mb']:.2f} MB")
        print(f"Jumlah permintaan: {data['total_requests']}")
        print(f"Aktivitas terakhir: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} tidak ditemukan")
        return None

def get_all_proxies_stats():
    """Mendapatkan statistik untuk semua proxy"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Pertama, dapatkan daftar semua 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=== Statistik untuk {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=== Total pengeluaran lalu lintas: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Kesalahan mendapatkan daftar proxy")
        return None

# Mendapatkan statistik untuk semua proxy
all_stats = get_all_proxies_stats()

Contoh-contoh ini menunjukkan dasar-dasar kerja dengan API. Untuk sistem produksi, tambahkan penanganan kesalahan, logika retry saat terjadi kegagalan jaringan, dan caching hasil untuk tidak melebihi rate limits penyedia.

Contoh kode dalam Node.js untuk memantau lalu lintas

Node.js sangat cocok untuk membuat mikroservis pemantauan yang berjalan di latar belakang dan mengirim pemberitahuan saat terjadi peristiwa kritis. Kita akan menggunakan pustaka axios untuk permintaan HTTP.

Kelas dasar untuk bekerja dengan API 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('Kesalahan mendapatkan saldo:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('Kesalahan mendapatkan statistik:', 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('Kesalahan mendapatkan riwayat lalu lintas:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Kesalahan mendapatkan statistik proxy ${proxyId}:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Pemantauan otomatis dengan pemberitahuan

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 - peringatan
      trafficCritical: 5,  // GB - tingkat kritis
      balanceWarning: 50   // USD - peringatan saldo
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] Memeriksa statistik...`);
      console.log(`Saldo: $${balance.balance.toFixed(2)}`);
      console.log(`Sisa lalu lintas: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Memeriksa ambang batas kritis
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `SANGAT KURANG LALU LINTAS: tersisa ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Lalu lintas sedikit: tersisa ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

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

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

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

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

    // Mengirim email (atur 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 = `
      Masalah terdeteksi dengan proxy:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Statistik saat ini:
      - Saldo: $${balance.balance.toFixed(2)}
      - Sisa lalu lintas: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Digunakan: ${balance.traffic_used_gb.toFixed(2)} GB
      - Proxy aktif: ${balance.active_proxies}
      
      Disarankan untuk mengisi saldo atau mengurangi beban.
    `;

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

  start() {
    console.log(`Memulai pemantauan proxy (pemeriksaan setiap ${this.checkInterval / 60000} menit)`);
    
    // Pemeriksaan pertama segera
    this.checkAndNotify();
    
    // Pemeriksaan berkala
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// Memulai pemantauan
const monitor = new ProxyMonitor(15); // pemeriksaan setiap 15 menit
monitor.start();

Kode ini membuat layanan latar belakang yang memeriksa statistik setiap 15 menit dan mengirim email pemberitahuan saat mencapai ambang batas kritis. Untuk proxy seluler, yang biasanya lebih mahal daripada proxy residensial, pemantauan semacam ini sangat penting untuk mengontrol pengeluaran.

Contoh permintaan melalui cURL

cURL adalah alat serbaguna untuk menguji API dari baris perintah. Berguna untuk memeriksa endpoint dengan cepat dan debugging integrasi.

Mendapatkan saldo

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

# Dengan format JSON yang indah (melalui jq)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Mengambil field tertentu
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Mendapatkan statistik untuk periode

# Statistik untuk 7 hari terakhir
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'

# Statistik untuk tipe proxy tertentu
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Mendapatkan daftar proxy aktif

# Daftar semua proxy aktif
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}'

# Menghitung jumlah proxy aktif
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Skrip Bash untuk pemeriksaan otomatis

#!/bin/bash

# Konfigurasi
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - ambang peringatan

# Mendapatkan statistik
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')

# Menampilkan statistik
echo "=== Statistik proxy $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Sisa lalu lintas: ${traffic_remaining} GB"
echo "Saldo: \$${balance}"
echo "Proxy aktif: ${active_proxies}"

# Memeriksa ambang batas
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  PERHATIAN: Lalu lintas sedikit! Tersisa ${traffic_remaining} GB"
  
  # Mengirim pemberitahuan (misalnya, melalui Telegram)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Lalu lintas proxy sedikit: ${traffic_remaining} GB"
fi

Simpan skrip ini sebagai check_proxy_stats.sh, berikan hak eksekusi (chmod +x check_proxy_stats.sh) dan tambahkan ke cron untuk menjalankan otomatis setiap jam:

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

Otomatisasi pemantauan dan pemberitahuan

Pemeriksaan manual statistik tidak efisien — diperlukan otomatisasi dengan pemberitahuan cerdas. Mari kita lihat sistem pemantauan lengkap dengan integrasi.

Integrasi dengan Telegram untuk pemberitahuan

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'):
        """Mengirim pesan ke 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"Kesalahan mengirim ke Telegram: {e}")
            return False

def monitor_proxy_with_telegram():
    """Pemantauan dengan pemberitahuan di Telegram"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Membuat pesan
        message = f"""
📊 *Statistik Proxy* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Saldo: ${balance['balance']:.2f}
📈 Digunakan: {balance['traffic_used_gb']:.2f} GB
📉 Tersisa: {balance['traffic_remaining_gb']:.2f} GB
🔌 Proxy aktif: {balance['active_proxies']}
        """
        
        # Memeriksa ambang batas kritis
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *SANGAT KURANG LALU LINTAS!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Disarankan untuk mengisi lalu lintas"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Kesalahan pemantauan proxy*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# Memulai pemantauan
monitor_proxy_with_telegram()

Integrasi dengan 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'):
        """Mengirim pemberitahuan ke Slack"""
        color = {
            'info': '#36a64f',
            'warning': '#ff9900',
            'critical': '#ff0000'
        }.get(level, '#cccccc')
        
        payload = {
            'attachments': [{
                'color': color,
                'title': title,
                'text': message,
                'footer': 'Pemantauan Proxy',
                'ts': int(datetime.now().timestamp())
            }]
        }
        
        try:
            response = requests.post(
                self.webhook_url,
                data=json.dumps(payload),
                headers={'Content-Type': 'application/json'},
                timeout=10
            )
            return response.status_code == 200
        except Exception as e:
            print(f"Kesalahan mengirim ke Slack: {e}")
            return False

def check_proxy_health():
    """Memeriksa kesehatan proxy dengan pemberitahuan"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Menganalisis status
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"Ditemukan {len(offline_proxies)} proxy tidak aktif:\n"
        for proxy in offline_proxies[:5]:  # lima pertama
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Proxy Tidak Aktif',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Sangat sedikit lalu lintas!',
            f"Tersisa {balance['traffic_remaining_gb']:.2f} GB. "
            f"Saldo: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Pengaturan pengisian otomatis

Beberapa penyedia memungkinkan melalui API tidak hanya untuk mendapatkan statistik, tetapi juga untuk secara otomatis mengisi saldo saat mencapai ambang batas:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Pengisian otomatis saat saldo rendah"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Lalu lintas di bawah ambang ({threshold_gb} GB), memulai pengisian...")
        
        # Permintaan untuk pengisian melalui 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 terisi sebesar ${topup_amount_usd}")
            
            # Mengirim pemberitahuan
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Pengisian otomatis\n\n"
                f"Jumlah: ${topup_amount_usd}\n"
                f"Sisa lalu lintas: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Alasan: mencapai ambang {threshold_gb} GB"
            )
        else:
            print(f"❌ Kesalahan pengisian: {topup_response.text}")
    else:
        print(f"Lalu lintas cukup: {balance['traffic_remaining_gb']:.2f} GB")

# Memulai pemeriksaan (dapat ditambahkan ke cron)
auto_topup_if_needed()

Membuat dasbor statistik Anda sendiri

Untuk memvisualisasikan data dari API, Anda dapat membuat dasbor web dengan grafik pengeluaran lalu lintas, distribusi berdasarkan negara dan tipe proxy. Mari kita lihat contoh sederhana menggunakan Flask + Chart.js.

Backend menggunakan 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):
        """Mendapatkan semua data untuk dasbor"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Saldo dan statistik umum
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Riwayat untuk 30 hari terakhir
        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()
        
        # Daftar proxy
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Agregasi data
        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  # dalam 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():
    """Halaman utama dasbor"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """API endpoint untuk mendapatkan statistik"""
    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 dengan grafik (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Dasbor Statistik 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>📊 Dasbor Statistik 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>Sisa lalu lintas</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Digunakan</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Proxy Aktif</div>
      <div class="stat-value" id="active-proxies">-</div>
    </div>
  </div>

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

  <script>
    async function fetchData() {
      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 chart = new Chart(ctx, {
        type: 'line',
        data: {
          labels: data.history.map(item => item.date),
          datasets: [{
            label: 'Penggunaan Lalu Lintas (GB)',
            data: data.history.map(item => item.traffic_gb),
            borderColor: 'rgba(75, 192, 192, 1)',
            borderWidth: 2,
            fill: false
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

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