प्रॉक्सी का उपयोग करने के आँकड़े API के माध्यम से कैसे प्राप्त करें: ट्रैफ़िक की गणना का स्वचालन

यदि आप कई प्रॉक्सी के साथ काम कर रहे हैं - आर्बिट्राज, पार्सिंग या मल्टी-एकाउंटिंग के लिए - ट्रैफ़िक के खर्च की मैनुअल निगरानी एक बुरे सपने में बदल जाती है। प्रॉक्सी प्रदाताओं का API आँकड़ों को स्वचालित करने की अनुमति देता है: ट्रैफ़िक का शेष, सक्रिय सत्र, IP पते के अनुसार खर्च और उपयोग का इतिहास। इस मार्गदर्शिका में, हम Python, Node.js और cURL पर कोड के उदाहरणों के माध्यम से आँकड़ों की गणना के लिए API को एकीकृत करने के तरीके पर चर्चा करेंगे।

प्रॉक्सी आँकड़ों के स्वचालन की आवश्यकता

जब आप विभिन्न परियोजनाओं के लिए 10-50 प्रॉक्सी का प्रबंधन करते हैं, तो प्रदाता के व्यक्तिगत खाते के माध्यम से बैलेंस और ट्रैफ़िक के खर्च की मैनुअल जांच अप्रभावी हो जाती है। API कई महत्वपूर्ण कार्यों को हल करता है:

आर्बिट्राजर्स के लिए, जो कई खातों के माध्यम से विज्ञापन चलाते हैं, यह जानना महत्वपूर्ण है कि कौन से प्रॉक्सी सक्रिय हैं और कितनी ट्रैफ़िक शेष है - समाप्त सीमा के कारण अचानक अवरोध हजारों डॉलर का नुकसान कर सकता है। SMM एजेंसियों के लिए, जो Instagram या TikTok में ग्राहक खातों का प्रबंधन करती हैं, स्वचालन प्रॉक्सी के उपयोग के लिए सटीक चालान जारी करने की अनुमति देता है।

मार्केटप्लेस पार्सर्स (Wildberries, Ozon, Avito) मुख्य प्रॉक्सी पर सीमा समाप्त होने पर स्वचालित रूप से बैकअप प्रॉक्सी पर स्विच कर सकते हैं। API ऐसी विफलता-प्रतिरोधी प्रणालियाँ बनाने की अनुमति देता है जो बिना किसी मैनुअल हस्तक्षेप के 24/7 काम करती हैं।

प्रॉक्सी प्रदाताओं के API के साथ काम करने के मूलभूत सिद्धांत

अधिकांश आधुनिक प्रॉक्सी प्रदाता सेवा प्रबंधन के लिए RESTful API प्रदान करते हैं। API मानक योजना के अनुसार काम करता है: आप प्रमाणीकरण पैरामीटर के साथ एक निश्चित एंडपॉइंट पर HTTP अनुरोध भेजते हैं, सर्वर डेटा के साथ JSON लौटाता है।

प्रॉक्सी प्रदाता से API के माध्यम से JSON उत्तर की सामान्य संरचना इस प्रकार है:

{
  "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 के साथ काम करते समय रेट लिमिट्स (अनुरोधों की संख्या पर सीमाएँ) को ध्यान में रखना महत्वपूर्ण है। अधिकांश प्रदाता प्रति मिनट 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 क्रेडेंशियल्स पर्यावरण चर से
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 के साथ बुनियादी काम दिखाते हैं। प्रोडक्शन सिस्टम के लिए, त्रुटियों को संभालने, नेटवर्क विफलताओं पर पुनः प्रयास करने की लॉजिक और परिणामों को कैश करने को जोड़ें ताकि प्रदाता की रेट लिमिट्स को पार न करें।

ट्रैफ़िक की निगरानी के लिए Node.js पर कोड के उदाहरण

Node.js बैकग्राउंड में काम करने वाले निगरानी माइक्रोसर्विस बनाने के लिए उत्कृष्ट है और महत्वपूर्ण घटनाओं पर सूचनाएँ भेजता है। HTTP अनुरोधों के लिए axios पुस्तकालय का उपयोग करें।

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}`);
    });

    // ईमेल भेजना (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 मिनट में आँकड़ों की जांच करती है और महत्वपूर्ण सीमाओं पर ईमेल सूचनाएँ भेजती है। मोबाइल प्रॉक्सी, जो आमतौर पर रेसिडेंशियल से महंगे होते हैं, के लिए इस तरह की निगरानी खर्चों पर नियंत्रण के लिए विशेष रूप से महत्वपूर्ण है।

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) और इसे हर घंटे स्वचालित रूप से चलाने के लिए क्रोन में जोड़ें:

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': 'प्रॉक्सी मॉनिटर',
                '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")

# जांच शुरू करना (क्रोन में जोड़ सकते हैं)
auto_topup_if_needed()

अपने स्वयं के आँकड़ों का डैशबोर्ड बनाना

API से डेटा को विज़ुअलाइज़ करने के लिए, आप ट्रैफ़िक खर्च, देशों और प्रॉक्सी प्रकारों के वितरण के चार्ट के साथ एक वेब डैशबोर्ड बना सकते हैं। चलिए Flask + Chart.js पर एक सरल उदाहरण पर विचार करते हैं।

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)

ग्राफ़ के साथ फ्रंटएंड (dashboard.html)

<!DOCTYPE html>
<html>
<head>
  <title>प्रॉक्सी आँकड़े डैशबोर्ड</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>📊 प्रॉक्सी आँकड़े डैशबोर्ड</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>उपयोग किया गया</div>
      <div class="stat-value" id="traffic-used">-</div>
    </div>
    <div class="stats-card">
      <div>सक्रिय प्रॉक्सी</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(stat => stat.date),
          datasets: [{
            label: 'ट्रैफ़िक खर्च (GB)',
            data: data.history.map(stat => stat.traffic_gb),
            borderColor: 'rgba(75, 192, 192, 1)',
            borderWidth: 2,
            fill: false
          }]
        },
        options: {
          responsive: true,
          scales: {
            y: {
              beginAtZero: true
            }
          }
        }
      });
    }

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