API Üzerinden Proxy Kullanım İstatistiklerini Alma: Trafik Hesaplamasında Otomasyon

Eğer çok sayıda proxy ile çalışıyorsanız — arbitraj, veri çekme veya çoklu hesap yönetimi için — trafik tüketimini manuel olarak kontrol etmek bir kabusa dönüşebilir. Proxy sağlayıcılarının API'si, istatistikleri otomatikleştirmenizi sağlar: trafik bakiyesi, aktif oturumlar, IP adreslerine göre tüketim ve kullanım geçmişi. Bu kılavuzda, Python, Node.js ve cURL ile kod örnekleri üzerinden istatistik hesaplaması için API'yi nasıl entegre edeceğimizi inceleyeceğiz.

Proxy istatistiklerinin otomatikleştirilmesi neden gereklidir

Eğer farklı projeler için 10-50 proxy yönetiyorsanız, sağlayıcının kontrol paneli üzerinden bakiye ve trafik tüketimini manuel olarak kontrol etmek etkisiz hale gelir. API, birkaç kritik sorunu çözer:

Çok sayıda hesap üzerinden reklam yürüten arbitrajcılar için, hangi proxy'lerin aktif olduğunu ve ne kadar trafik kaldığını bilmek kritik öneme sahiptir — limitin tükenmesi nedeniyle aniden yaşanan bir engelleme, binlerce dolarlık kayıplara neden olabilir. Instagram veya TikTok'ta müşteri hesaplarını yöneten SMM ajansları için otomasyon, proxy kullanımı için doğru faturalar kesmeyi sağlar.

Pazar yerleri (Wildberries, Ozon, Avito) veri çekme işlemlerinde, ana proxy'lerin limitinin tükenmesi durumunda otomatik olarak yedek proxy'lere geçiş yapabilirler. API, manuel müdahale olmadan 24/7 çalışan kesintisiz sistemler kurma imkanı sağlar.

Proxy sağlayıcılarının API'sinin temelleri

Modern proxy sağlayıcılarının çoğu, hizmeti yönetmek için RESTful API sunmaktadır. API, standart bir şemaya göre çalışır: belirli bir uç noktaya kimlik doğrulama parametreleriyle bir HTTP isteği gönderirsiniz, sunucu veri içeren bir JSON döner.

Proxy sağlayıcısından gelen tipik bir JSON yanıt yapısı şu şekildedir:

{
  "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 ile çalışırken rate limits (istek sayısı sınırlamaları) dikkate alınmalıdır. Çoğu sağlayıcı dakikada 60-300 istek yapılmasına izin verir. İstatistikleri izlemek için bu yeterlidir — genellikle istekler 5-15 dakikada bir yapılır.

Kimlik doğrulama ve API anahtarı alma

API ile çalışmanın ilk adımı, kimlik doğrulama anahtarını almaktır. Farklı sağlayıcıların süreçleri farklılık gösterir, ancak genel mantık aynıdır:

Proxy sağlayıcılarının API'sinde iki ana kimlik doğrulama yöntemi vardır:

Önemli: API anahtarlarını, Git deposuna girecek kodda asla saklamayın. Ortam değişkenleri (.env dosyaları) veya gizli yöneticileri (AWS Secrets Manager, HashiCorp Vault) kullanın. Anahtar sızarsa — hemen kontrol panelinde iptal edin ve yenisini oluşturun.

İstatistik almak için temel uç noktalar

Her sağlayıcının API yapısı farklı olsa da, çoğu istatistik almak için standart bir uç nokta seti sunar. Tipik yöntemleri inceleyelim:

İstek parametreleri genellikle zaman dilimleri ve filtreler içerir:

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

Konut proxy'leri ile çalışırken, oturum istatistiklerini almak için uç nokta özellikle önemlidir, çünkü genellikle IP rotasyonu kullanırlar. API, belirli bir dönem içinde kaç benzersiz IP kullanıldığını ve her oturum üzerinden ne kadar trafik geçtiğini takip etmeyi sağlar.

İstatistik almak için Python kod örnekleri

Python, requests kütüphanesi sayesinde proxy ile çalışmayı otomatikleştirmek için en popüler dildir. API üzerinden istatistik almak için pratik örnekleri inceleyelim.

Temel bakiye ve trafik isteği

import requests
import os
from datetime import datetime

# API kimlik bilgileri ortam değişkenlerinden alınır
API_KEY = os.getenv('PROXY_API_KEY')
BASE_URL = 'https://api.proxyprovider.com/v1'

def get_balance_statistics():
    """Bakiye ve genel istatistiklerin alınması"""
    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 istatistikleri {datetime.now().strftime('%Y-%m-%d %H:%M')} ===")
        print(f"Bakiye: ${data['balance']:.2f}")
        print(f"Kullanılan trafik: {data['traffic_used_gb']:.2f} GB")
        print(f"Trafik kalanı: {data['traffic_remaining_gb']:.2f} GB")
        print(f"Aktif proxy sayısı: {data['active_proxies']}")
        
        return data
        
    except requests.exceptions.RequestException as e:
        print(f"İstek hatası: {e}")
        return None

# Fonksiyonu çağır
stats = get_balance_statistics()

Belirli bir dönem için detaylı istatistik alma

from datetime import datetime, timedelta
import requests

def get_traffic_history(days=7):
    """N gün için trafik tüketim geçmişinin alınması"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Zaman diliminin hesaplanması
    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=== Son {days} gün için trafik tüketimi ===")
        for day in data['daily_stats']:
            print(f"{day['date']}: {day['traffic_gb']:.2f} GB "
                  f"({day['requests']} istek)")
        
        total = sum(day['traffic_gb'] for day in data['daily_stats'])
        print(f"\nDönem toplamı: {total:.2f} GB")
        
        return data
    else:
        print(f"Hata {response.status_code}: {response.text}")
        return None

# Haftalık istatistik alma
history = get_traffic_history(7)

Belirli proxy'lerin istatistiklerini izleme

def get_proxy_statistics(proxy_id):
    """Belirli bir proxy için istatistiklerin alınması"""
    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 {proxy_id} istatistikleri ===")
        print(f"IP adresi: {data['ip_address']}")
        print(f"Ülke: {data['country']}")
        print(f"Tür: {data['proxy_type']}")
        print(f"Durum: {data['status']}")
        print(f"Kullanılan trafik: {data['traffic_used_mb']:.2f} MB")
        print(f"İstek sayısı: {data['total_requests']}")
        print(f"Son aktivite: {data['last_activity']}")
        
        return data
    else:
        print(f"Proxy {proxy_id} bulunamadı")
        return None

def get_all_proxies_stats():
    """Tüm proxy'lerin istatistiklerinin alınması"""
    headers = {'Authorization': f'Bearer {API_KEY}'}
    
    # Öncelikle tüm proxy'lerin listesini al
    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)} proxy için istatistik ===\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=== Toplam trafik tüketimi: {total_traffic/1024:.2f} GB ===")
        
        return proxies
    else:
        print("Proxy listesini alma hatası")
        return None

# Tüm proxy'lerin istatistiklerini alma
all_stats = get_all_proxies_stats()

Bu örnekler, API ile temel çalışmayı göstermektedir. Üretim sistemleri için hata işleme, ağ hatalarında tekrar deneme mantığı ve sonuçların önbelleğe alınmasını ekleyin, böylece sağlayıcının rate limits'ini aşmazsınız.

Trafik izleme için Node.js kod örnekleri

Node.js, arka planda çalışan ve kritik olaylar gerçekleştiğinde bildirim gönderen izleme mikro hizmetleri oluşturmak için mükemmel bir seçimdir. HTTP istekleri için axios kütüphanesini kullanacağız.

API ile çalışma için temel sınıf

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('Bakiye alma hatası:', error.message);
      throw error;
    }
  }

  async getStatistics(params = {}) {
    try {
      const response = await this.client.get('/statistics', { params });
      return response.data;
    } catch (error) {
      console.error('İstatistik alma hatası:', 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('Trafik geçmişi alma hatası:', error.message);
      throw error;
    }
  }

  async getProxyStats(proxyId) {
    try {
      const response = await this.client.get(`/statistics/proxy/${proxyId}`);
      return response.data;
    } catch (error) {
      console.error(`Proxy ${proxyId} istatistiklerini alma hatası:`, error.message);
      throw error;
    }
  }
}

module.exports = ProxyAPIClient;

Otomatik izleme ve bildirimler

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 - uyarı
      trafficCritical: 5,  // GB - kritik seviye
      balanceWarning: 50   // USD - bakiye uyarısı
    };
  }

  async checkAndNotify() {
    try {
      const balance = await this.api.getBalance();
      
      console.log(`[${new Date().toISOString()}] İstatistik kontrol ediliyor...`);
      console.log(`Bakiye: $${balance.balance.toFixed(2)}`);
      console.log(`Trafik kalanı: ${balance.traffic_remaining_gb.toFixed(2)} GB`);

      // Kritik eşiklerin kontrolü
      const alerts = [];

      if (balance.traffic_remaining_gb <= this.thresholds.trafficCritical) {
        alerts.push({
          level: 'critical',
          message: `KRİTİK DERECEDE DÜŞÜK TRAFİK: kalan ${balance.traffic_remaining_gb.toFixed(2)} GB!`
        });
      } else if (balance.traffic_remaining_gb <= this.thresholds.trafficWarning) {
        alerts.push({
          level: 'warning',
          message: `Düşük trafik: kalan ${balance.traffic_remaining_gb.toFixed(2)} GB`
        });
      }

      if (balance.balance <= this.thresholds.balanceWarning) {
        alerts.push({
          level: 'warning',
          message: `Düşük bakiye: $${balance.balance.toFixed(2)}`
        });
      }

      // Bildirim gönderme
      if (alerts.length > 0) {
        await this.sendAlerts(alerts, balance);
      }

      return { balance, alerts };
    } catch (error) {
      console.error('İzleme hatası:', error);
      await this.sendErrorNotification(error);
    }
  }

  async sendAlerts(alerts, balance) {
    console.log('\n⚠️  DİKKAT! Sorunlar tespit edildi:');
    alerts.forEach(alert => {
      console.log(`[${alert.level.toUpperCase()}] ${alert.message}`);
    });

    // E-posta gönderimi (SMTP'yi ayarlayın)
    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 = `
      Proxy ile ilgili sorunlar tespit edildi:
      
      ${alerts.map(a => `- ${a.message}`).join('\n')}
      
      Mevcut istatistik:
      - Bakiye: $${balance.balance.toFixed(2)}
      - Trafik kalanı: ${balance.traffic_remaining_gb.toFixed(2)} GB
      - Kullanılan: ${balance.traffic_used_gb.toFixed(2)} GB
      - Aktif proxy sayısı: ${balance.active_proxies}
      
      Bakiyenin doldurulması veya yükün azaltılması önerilir.
    `;

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

  start() {
    console.log(`Proxy izleme başlatılıyor (her ${this.checkInterval / 60000} dakikada bir kontrol)`);
    
    // İlk kontrol hemen
    this.checkAndNotify();
    
    // Periyodik kontroller
    setInterval(() => {
      this.checkAndNotify();
    }, this.checkInterval);
  }
}

// İzlemeyi başlat
const monitor = new ProxyMonitor(15); // her 15 dakikada bir kontrol
monitor.start();

Bu kod, her 15 dakikada bir istatistikleri kontrol eden ve kritik eşiklere ulaşıldığında e-posta bildirimleri gönderen bir arka plan hizmeti oluşturur. Mobil proxy'ler, genellikle konut proxy'lerinden daha pahalıdır, bu nedenle bu tür bir izleme, harcamaları kontrol etmek için özellikle önemlidir.

cURL ile istek örnekleri

cURL, komut satırından API'leri test etmek için evrensel bir araçtır. Uç noktaları hızlı bir şekilde kontrol etmek ve entegrasyonları hata ayıklamak için faydalıdır.

Bakiye alma

# Temel bakiye isteği
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  -H "Content-Type: application/json"

# Güzel JSON formatlama (jq ile)
curl -X GET "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

# Belirli bir alanı çıkarma
curl -s "https://api.proxyprovider.com/v1/balance" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.traffic_remaining_gb'

Belirli bir dönem için istatistik alma

# Son 7 gün için istatistik
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'

# Belirli bir proxy türü için istatistik
curl -X GET "https://api.proxyprovider.com/v1/statistics?proxy_type=residential&country=US" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.'

Aktif proxy'lerin listesini alma

# Tüm aktif proxy'lerin listesi
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}'

# Aktif proxy sayısını sayma
curl -s "https://api.proxyprovider.com/v1/proxies/list?status=active" \
  -H "Authorization: Bearer YOUR_API_KEY" \
  | jq '.proxies | length'

Otomatik kontrol için Bash scripti

#!/bin/bash

# Konfigürasyon
API_KEY="YOUR_API_KEY"
BASE_URL="https://api.proxyprovider.com/v1"
TRAFFIC_THRESHOLD=10  # GB - uyarı eşiği

# İstatistik alma
response=$(curl -s "${BASE_URL}/balance" \
  -H "Authorization: Bearer ${API_KEY}")

# JSON ayrıştırma
traffic_remaining=$(echo "$response" | jq -r '.traffic_remaining_gb')
balance=$(echo "$response" | jq -r '.balance')
active_proxies=$(echo "$response" | jq -r '.active_proxies')

# İstatistikleri yazdırma
echo "=== Proxy istatistikleri $(date '+%Y-%m-%d %H:%M:%S') ==="
echo "Trafik kalanı: ${traffic_remaining} GB"
echo "Bakiye: \$${balance}"
echo "Aktif proxy sayısı: ${active_proxies}"

# Eşiklerin kontrolü
if (( $(echo "$traffic_remaining < $TRAFFIC_THRESHOLD" | bc -l) )); then
  echo "⚠️  DİKKAT: Düşük trafik! Kalan ${traffic_remaining} GB"
  
  # Bildirim gönderimi (örneğin, Telegram üzerinden)
  # curl -s -X POST "https://api.telegram.org/bot${TELEGRAM_BOT_TOKEN}/sendMessage" \
  #   -d chat_id="${TELEGRAM_CHAT_ID}" \
  #   -d text="⚠️ Düşük trafik proxy: ${traffic_remaining} GB"
fi

Bu scripti check_proxy_stats.sh olarak kaydedin, çalıştırma izinleri verin (chmod +x check_proxy_stats.sh) ve her saat otomatik olarak çalışması için cron'a ekleyin:

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

İzleme ve bildirimlerin otomatikleştirilmesi

Manuel istatistik kontrolü etkisizdir — akıllı bildirimlerle otomatikleştirme gereklidir. Entegrasyonlarla tam bir izleme sistemi inceleyelim.

Bildirimler için Telegram ile entegrasyon

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'da mesaj gönderme"""
        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'a gönderim hatası: {e}")
            return False

def monitor_proxy_with_telegram():
    """Telegram ile bildirimli izleme"""
    api = ProxyAPIClient()
    notifier = TelegramNotifier()
    
    try:
        balance = api.get_balance()
        
        # Mesaj oluşturma
        message = f"""
📊 *Proxy İstatistikleri* ({datetime.now().strftime('%H:%M %d.%m.%Y')})

💰 Bakiye: ${balance['balance']:.2f}
📈 Kullanılan: {balance['traffic_used_gb']:.2f} GB
📉 Kalan: {balance['traffic_remaining_gb']:.2f} GB
🔌 Aktif proxy sayısı: {balance['active_proxies']}
        """
        
        # Kritik eşiklerin kontrolü
        if balance['traffic_remaining_gb'] < 5:
            message += "\n⚠️ *KRİTİK DERECEDE DÜŞÜK TRAFİK!*"
            notifier.send_message(message)
        elif balance['traffic_remaining_gb'] < 10:
            message += "\n⚡ Trafiği doldurmanız önerilir"
            notifier.send_message(message)
        
        return balance
        
    except Exception as e:
        error_msg = f"❌ *Proxy izleme hatası*\n\n{str(e)}"
        notifier.send_message(error_msg)
        raise

# İzlemeyi başlat
monitor_proxy_with_telegram()

Slack ile entegrasyon

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'ta bildirim gönderme"""
        color = {
            'info': '#36a64f',
            'warning': '#ff9900',
            'critical': '#ff0000'
        }.get(level, '#cccccc')
        
        payload = {
            'attachments': [{
                'color': color,
                'title': title,
                'text': message,
                'footer': 'Proxy İzleyici',
                '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'a gönderim hatası: {e}")
            return False

def check_proxy_health():
    """Proxy sağlığını kontrol etme ve bildirim gönderme"""
    api = ProxyAPIClient()
    slack = SlackNotifier(os.getenv('SLACK_WEBHOOK_URL'))
    
    balance = api.get_balance()
    proxies = api.get_all_proxies()
    
    # Durum analizi
    offline_proxies = [p for p in proxies if p['status'] != 'active']
    
    if len(offline_proxies) > 0:
        message = f"{len(offline_proxies)} aktif olmayan proxy tespit edildi:\n"
        for proxy in offline_proxies[:5]:  # ilk 5
            message += f"- {proxy['ip_address']} ({proxy['country']})\n"
        
        slack.send_alert(
            'Aktif Olmayan Proxyler',
            message,
            level='warning'
        )
    
    if balance['traffic_remaining_gb'] < 5:
        slack.send_alert(
            'Kritik derecede düşük trafik!',
            f"Kalan {balance['traffic_remaining_gb']:.2f} GB. "
            f"Bakiye: ${balance['balance']:.2f}",
            level='critical'
        )

check_proxy_health()

Otomatik bakiye doldurma ayarları

Bazı sağlayıcılar, API üzerinden yalnızca istatistik almakla kalmayıp, aynı zamanda belirli bir eşik seviyesine ulaşıldığında otomatik olarak bakiye doldurma işlemi yapmanıza da izin verir:

def auto_topup_if_needed(threshold_gb=10, topup_amount_usd=100):
    """Düşük bakiye durumunda otomatik bakiye doldurma"""
    api = ProxyAPIClient()
    
    balance = api.get_balance()
    
    if balance['traffic_remaining_gb'] < threshold_gb:
        print(f"Trafik eşik seviyesinin altında ({threshold_gb} GB), bakiye doldurma işlemi başlatılıyor...")
        
        # API üzerinden bakiye doldurma isteği
        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"✅ Bakiye ${topup_amount_usd} olarak dolduruldu")
            
            # Bildirim gönderimi
            notifier = TelegramNotifier()
            notifier.send_message(
                f"💳 Otomatik bakiye doldurma\n\n"
                f"Tutar: ${topup_amount_usd}\n"
                f"Önceki trafik: {balance['traffic_remaining_gb']:.2f} GB\n"
                f"Neden: eşik {threshold_gb} GB'a ulaşıldı"
            )
        else:
            print(f"❌ Bakiye doldurma hatası: {topup_response.text}")
    else:
        print(f"Trafik yeterli: {balance['traffic_remaining_gb']:.2f} GB")

# Kontrolü başlat (cron'a eklenebilir)
auto_topup_if_needed()

Kendi istatistik panonuzu oluşturma

API'den gelen verilerin görselleştirilmesi için trafik tüketimi, ülkelere ve proxy türlerine göre dağılım grafikleri ile bir web panosu oluşturabilirsiniz. Flask + Chart.js kullanarak basit bir örneği inceleyelim.

Flask ile Backend

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):
        """Panodaki tüm verilerin alınması"""
        headers = {'Authorization': f'Bearer {self.api_key}'}
        
        # Bakiye ve genel istatistik
        balance = requests.get(
            f'{self.base_url}/balance',
            headers=headers
        ).json()
        
        # Son 30 gün için geçmiş
        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()
        
        # Proxy listesi
        proxies = requests.get(
            f'{self.base_url}/proxies/list',
            headers=headers
        ).json()
        
        # Veri toplama
        traffic_by_country = {}
        traffic_by_type = {}
        
        for proxy in proxies.get('proxies', []):
            country = proxy.get('country', 'Bilinmiyor')
            proxy_type = proxy.get('proxy_type', 'Bilinmiyor')
            traffic = proxy.get('traffic_used_mb', 0) / 1024  # GB cinsinden
            
            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():
    """Panonun ana sayfası"""
    return render_template('dashboard.html')

@app.route('/api/stats')
def get_stats():
    """İstatistikleri almak için API uç noktası"""
    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)

Grafiklerle Frontend (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>Proxy İstatistikleri Panosu</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 İstatistikleri Panosu</h1>
  
  <div style="display: grid; grid-template-columns: repeat(4, 1fr); gap: 10px;">
    <div class="stats-card">
      <div>Bakiye</div>
      <div class="stat-value" id="balance">-</div>
    </div>
    <div class="stats-card">
      <div>Trafik kalanı</div>
      <div class="stat-value" id="traffic-remaining">-</div>
    </div>
    <div class="stats-card">
      <div>Kullanılan</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>Aktif Proxy Sayısı</div>
      <div class="stat-value" id="active-proxies">-</div>
    </div>
  </div>

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

  <script>
    async function fetchStats() {
      const response = await fetch('/api/stats');
      const data = await response.json();
      
      document.getElementById('balance').innerText = data.balance.balance.toFixed(2);
      document.getElementById('traffic-remaining').innerText = data.balance.traffic_remaining_gb.toFixed(2);
      document.getElementById('traffic-used').innerText = data.balance.traffic_used_gb.toFixed(2);
      document.getElementById('active-proxies').innerText = data.balance.active_proxies;

      const ctx = document.getElementById('trafficChart').getContext('2d');
      const chart = new Chart(ctx, {
        type: 'line',
        data: {
          labels: data.history.map(stat => stat.date),
          datasets: [{
            label: 'Trafik Tüketimi (GB)',
            data: data.history.map(stat => stat.traffic_gb),
            borderColor: 'rgba(75, 192, 192, 1)',
            backgroundColor: 'rgba(75, 192, 192, 0.2)',
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

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