SEO Optimization
& Monitoring

import requests
from bs4 import BeautifulSoup
import pandas as pd
from urllib.parse import urlencode
import time
import random

class SEORankTracker:
    def __init__(self, proxy_pool):
        self.proxy_pool = proxy_pool
        self.session = requests.Session()
        
    def get_proxy(self):
        """Get a random proxy from the pool"""
        proxy = random.choice(self.proxy_pool)
        return {
            'http': f"http://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}",
            'https': f"https://{proxy['user']}:{proxy['pass']}@{proxy['host']}:{proxy['port']}"
        }
    
    def search_google(self, query, location='', num_results=100):
        """Search Google and return SERP results"""
        params = {
            'q': query,
            'num': num_results,
            'hl': 'en',
            'gl': location.lower() if location else 'us'
        }
        
        url = f"https://www.google.com/search?{urlencode(params)}"
        
        headers = {
            'User-Agent': self.get_random_user_agent(),
            'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
            'Accept-Language': 'en-US,en;q=0.5',
            'Accept-Encoding': 'gzip, deflate',
            'Connection': 'keep-alive',
        }
        
        try:
            response = self.session.get(
                url, 
                headers=headers, 
                proxies=self.get_proxy(),
                timeout=30
            )
            
            if response.status_code == 200:
                return self.parse_serp(response.text, query)
            else:
                print(f"Error: {response.status_code}")
                return []
                
        except Exception as e:
            print(f"Request failed: {e}")
            return []
    
    def parse_serp(self, html, query):
        """Parse SERP results from HTML"""
        soup = BeautifulSoup(html, 'html.parser')
        results = []
        
        # Find organic search results
        search_results = soup.find_all('div', class_='g')
        
        for i, result in enumerate(search_results[:100], 1):
            try:
                # Extract title
                title_elem = result.find('h3')
                title = title_elem.get_text() if title_elem else ''
                
                # Extract URL
                link_elem = result.find('a')
                url = link_elem.get('href') if link_elem else ''
                
                # Extract snippet
                snippet_elem = result.find('span', class_='st') or result.find('div', class_='s')
                snippet = snippet_elem.get_text() if snippet_elem else ''
                
                if title and url:
                    results.append({
                        'position': i,
                        'title': title,
                        'url': url,
                        'snippet': snippet,
                        'query': query,
                        'timestamp': time.time()
                    })
                    
            except Exception as e:
                continue
        
        return results
    
    def track_keywords(self, keywords, domain, location=''):
        """Track rankings for multiple keywords"""
        rankings = []
        
        for keyword in keywords:
            print(f"Tracking: {keyword}")
            
            results = self.search_google(keyword, location)
            
            # Find domain position
            domain_position = None
            for result in results:
                if domain in result['url']:
                    domain_position = result['position']
                    break
            
            rankings.append({
                'keyword': keyword,
                'domain': domain,
                'position': domain_position,
                'location': location,
                'total_results': len(results),
                'timestamp': time.time()
            })
            
            # Rate limiting
            time.sleep(random.uniform(2, 5))
        
        return rankings
    
    def competitor_analysis(self, keywords, competitors):
        """Analyze competitor rankings"""
        analysis = []
        
        for keyword in keywords:
            results = self.search_google(keyword)
            
            keyword_data = {
                'keyword': keyword,
                'competitors': {},
                'top_10': [r['url'] for r in results[:10]]
            }
            
            # Check competitor positions
            for competitor in competitors:
                for result in results:
                    if competitor in result['url']:
                        keyword_data['competitors'][competitor] = result['position']
                        break
                else:
                    keyword_data['competitors'][competitor] = None
            
            analysis.append(keyword_data)
            time.sleep(random.uniform(3, 6))
        
        return analysis
    
    def get_random_user_agent(self):
        user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
        ]
        return random.choice(user_agents)

# Usage
proxy_pool = [
    {'host': 'proxy1.nyronproxies.com', 'port': 8000, 'user': 'username', 'pass': 'password'},
    {'host': 'proxy2.nyronproxies.com', 'port': 8000, 'user': 'username', 'pass': 'password'},
]

tracker = SEORankTracker(proxy_pool)

# Track rankings
keywords = ['seo tools', 'rank tracking', 'serp analysis']
domain = 'example.com'
rankings = tracker.track_keywords(keywords, domain, 'US')

# Competitor analysis
competitors = ['competitor1.com', 'competitor2.com']
analysis = tracker.competitor_analysis(keywords, competitors)

# Save results
df_rankings = pd.DataFrame(rankings)
df_rankings.to_csv('seo_rankings.csv', index=False)
print("SEO tracking completed!")

const axios = require('axios');
const cheerio = require('cheerio');
const HttpsProxyAgent = require('https-proxy-agent');
const fs = require('fs').promises;

class SERPMonitor {
  constructor(proxyPool) {
    this.proxyPool = proxyPool;
    this.results = [];
  }

  getRandomProxy() {
    const proxy = this.proxyPool[Math.floor(Math.random() * this.proxyPool.length)];
    return `http://${proxy.user}:${proxy.pass}@${proxy.host}:${proxy.port}`;
  }

  createClient() {
    const proxyUrl = this.getRandomProxy();
    return axios.create({
      httpsAgent: new HttpsProxyAgent(proxyUrl),
      timeout: 30000,
      headers: {
        'User-Agent': this.getRandomUserAgent(),
        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
        'Accept-Language': 'en-US,en;q=0.9',
        'Accept-Encoding': 'gzip, deflate, br',
        'Connection': 'keep-alive'
      }
    });
  }

  async searchGoogle(query, location = 'us', numResults = 100) {
    const client = this.createClient();
    
    const params = new URLSearchParams({
      q: query,
      num: numResults,
      hl: 'en',
      gl: location
    });

    try {
      const response = await client.get(`https://www.google.com/search?${params}`);
      return this.parseSERP(response.data, query);
    } catch (error) {
      console.error(`Search failed for "${query}": ${error.message}`);
      return [];
    }
  }

  parseSERP(html, query) {
    const $ = cheerio.load(html);
    const results = [];
    
    $('.g').each((index, element) => {
      const $element = $(element);
      
      const title = $element.find('h3').text().trim();
      const url = $element.find('a').first().attr('href');
      const snippet = $element.find('.VwiC3b, .s').text().trim();
      
      if (title && url && !url.startsWith('/search')) {
        results.push({
          position: index + 1,
          title,
          url,
          snippet,
          query,
          timestamp: new Date().toISOString()
        });
      }
    });
    
    return results;
  }

  async trackKeywordRankings(keywords, targetDomain, location = 'us') {
    const rankings = [];
    
    for (const keyword of keywords) {
      console.log(`Tracking keyword: ${keyword}`);
      
      try {
        const results = await this.searchGoogle(keyword, location);
        
        // Find target domain position
        const domainResult = results.find(result => 
          result.url.includes(targetDomain)
        );
        
        rankings.push({
          keyword,
          domain: targetDomain,
          position: domainResult ? domainResult.position : null,
          location,
          totalResults: results.length,
          timestamp: new Date().toISOString(),
          topCompetitors: results.slice(0, 5).map(r => ({
            position: r.position,
            domain: new URL(r.url).hostname,
            title: r.title
          }))
        });
        
        // Rate limiting
        await this.delay(Math.random() * 3000 + 2000);
        
      } catch (error) {
        console.error(`Error tracking ${keyword}: ${error.message}`);
      }
    }
    
    return rankings;
  }

  async monitorCompetitors(keywords, competitors, location = 'us') {
    const competitorData = [];
    
    for (const keyword of keywords) {
      console.log(`Analyzing competitors for: ${keyword}`);
      
      const results = await this.searchGoogle(keyword, location);
      const keywordAnalysis = {
        keyword,
        location,
        competitors: {},
        topDomains: results.slice(0, 10).map(r => new URL(r.url).hostname),
        timestamp: new Date().toISOString()
      };
      
      // Check each competitor's position
      competitors.forEach(competitor => {
        const competitorResult = results.find(result => 
          result.url.includes(competitor)
        );
        
        keywordAnalysis.competitors[competitor] = {
          position: competitorResult ? competitorResult.position : null,
          title: competitorResult ? competitorResult.title : null,
          url: competitorResult ? competitorResult.url : null
        };
      });
      
      competitorData.push(keywordAnalysis);
      await this.delay(Math.random() * 4000 + 3000);
    }
    
    return competitorData;
  }

  async generateSEOReport(data, filename = 'seo_report.json') {
    const report = {
      generatedAt: new Date().toISOString(),
      summary: {
        totalKeywords: data.length,
        averagePosition: this.calculateAveragePosition(data),
        topPerformingKeywords: this.getTopKeywords(data),
        improvementOpportunities: this.getImprovementOpportunities(data)
      },
      detailedData: data
    };
    
    await fs.writeFile(filename, JSON.stringify(report, null, 2));
    console.log(`SEO report saved to ${filename}`);
    return report;
  }

  calculateAveragePosition(data) {
    const positions = data
      .filter(item => item.position !== null)
      .map(item => item.position);
    
    return positions.length > 0 
      ? (positions.reduce((sum, pos) => sum + pos, 0) / positions.length).toFixed(2)
      : 'N/A';
  }

  getTopKeywords(data, limit = 5) {
    return data
      .filter(item => item.position !== null)
      .sort((a, b) => a.position - b.position)
      .slice(0, limit)
      .map(item => ({
        keyword: item.keyword,
        position: item.position
      }));
  }

  getImprovementOpportunities(data) {
    return data
      .filter(item => item.position === null || item.position > 10)
      .map(item => ({
        keyword: item.keyword,
        currentPosition: item.position || 'Not ranking',
        topCompetitors: item.topCompetitors?.slice(0, 3) || []
      }));
  }

  getRandomUserAgent() {
    const userAgents = [
      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
      'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
    ];
    return userAgents[Math.floor(Math.random() * userAgents.length)];
  }

  delay(ms) {
    return new Promise(resolve => setTimeout(resolve, ms));
  }
}

// Usage
const proxyPool = [
  { host: 'proxy1.nyronproxies.com', port: 8000, user: 'username', pass: 'password' },
  { host: 'proxy2.nyronproxies.com', port: 8000, user: 'username', pass: 'password' }
];

const monitor = new SERPMonitor(proxyPool);

async function runSEOAnalysis() {
  const keywords = ['seo optimization', 'rank tracking', 'serp monitoring'];
  const targetDomain = 'example.com';
  const competitors = ['competitor1.com', 'competitor2.com'];
  
  // Track rankings
  const rankings = await monitor.trackKeywordRankings(keywords, targetDomain);
  
  // Monitor competitors
  const competitorAnalysis = await monitor.monitorCompetitors(keywords, competitors);
  
  // Generate reports
  await monitor.generateSEOReport(rankings, 'ranking_report.json');
  await monitor.generateSEOReport(competitorAnalysis, 'competitor_report.json');
  
  console.log('SEO analysis completed!');
}

runSEOAnalysis().catch(console.error);

<?php
require_once 'vendor/autoload.php';

use GuzzleHttp\Client;
use Symfony\Component\DomCrawler\Crawler;

class SEOMonitoringSuite {
    private $proxyPool;
    private $clients = [];
    private $results = [];
    
    public function __construct($proxyPool) {
        $this->proxyPool = $proxyPool;
        $this->initializeClients();
    }
    
    private function initializeClients() {
        foreach ($this->proxyPool as $index => $proxy) {
            $proxyUrl = "http://{$proxy['user']}:{$proxy['pass']}@{$proxy['host']}:{$proxy['port']}";
            
            $this->clients[] = new Client([
                'proxy' => $proxyUrl,
                'timeout' => 30,
                'headers' => [
                    'User-Agent' => $this->getRandomUserAgent(),
                    'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
                    'Accept-Language' => 'en-US,en;q=0.9'
                ],
                'verify' => false
            ]);
        }
    }
    
    public function searchGoogle($query, $location = 'us', $numResults = 100) {
        $client = $this->getRandomClient();
        
        $params = http_build_query([
            'q' => $query,
            'num' => $numResults,
            'hl' => 'en',
            'gl' => $location
        ]);
        
        $url = "https://www.google.com/search?" . $params;
        
        try {
            $response = $client->get($url);
            $html = $response->getBody()->getContents();
            
            return $this->parseSERP($html, $query);
            
        } catch (Exception $e) {
            echo "Search failed for '{$query}': " . $e->getMessage() . "\n";
            return [];
        }
    }
    
    private function parseSERP($html, $query) {
        $crawler = new Crawler($html);
        $results = [];
        $position = 1;
        
        $crawler->filter('.g')->each(function (Crawler $node) use (&$results, &$position, $query) {
            try {
                $titleNode = $node->filter('h3');
                $linkNode = $node->filter('a')->first();
                $snippetNode = $node->filter('.VwiC3b, .s');
                
                if ($titleNode->count() > 0 && $linkNode->count() > 0) {
                    $title = $titleNode->text();
                    $url = $linkNode->attr('href');
                    $snippet = $snippetNode->count() > 0 ? $snippetNode->text() : '';
                    
                    if (!empty($title) && !empty($url) && strpos($url, '/search') !== 0) {
                        $results[] = [
                            'position' => $position,
                            'title' => trim($title),
                            'url' => $url,
                            'snippet' => trim($snippet),
                            'query' => $query,
                            'timestamp' => date('Y-m-d H:i:s')
                        ];
                        $position++;
                    }
                }
            } catch (Exception $e) {
                // Skip invalid results
            }
        });
        
        return $results;
    }
    
    public function trackKeywordRankings($keywords, $targetDomain, $location = 'us') {
        $rankings = [];
        
        foreach ($keywords as $keyword) {
            echo "Tracking keyword: {$keyword}\n";
            
            $results = $this->searchGoogle($keyword, $location);
            
            // Find target domain position
            $domainPosition = null;
            $domainResult = null;
            
            foreach ($results as $result) {
                if (strpos($result['url'], $targetDomain) !== false) {
                    $domainPosition = $result['position'];
                    $domainResult = $result;
                    break;
                }
            }
            
            $rankings[] = [
                'keyword' => $keyword,
                'domain' => $targetDomain,
                'position' => $domainPosition,
                'location' => $location,
                'total_results' => count($results),
                'top_competitors' => array_slice($results, 0, 5),
                'timestamp' => date('Y-m-d H:i:s')
            ];
            
            // Rate limiting
            sleep(rand(2, 5));
        }
        
        return $rankings;
    }
    
    public function analyzeCompetitors($keywords, $competitors, $location = 'us') {
        $analysis = [];
        
        foreach ($keywords as $keyword) {
            echo "Analyzing competitors for: {$keyword}\n";
            
            $results = $this->searchGoogle($keyword, $location);
            
            $keywordData = [
                'keyword' => $keyword,
                'location' => $location,
                'competitors' => [],
                'top_domains' => [],
                'timestamp' => date('Y-m-d H:i:s')
            ];
            
            // Extract top domains
            foreach (array_slice($results, 0, 10) as $result) {
                $domain = parse_url($result['url'], PHP_URL_HOST);
                $keywordData['top_domains'][] = $domain;
            }
            
            // Check competitor positions
            foreach ($competitors as $competitor) {
                $competitorData = [
                    'domain' => $competitor,
                    'position' => null,
                    'title' => null,
                    'url' => null
                ];
                
                foreach ($results as $result) {
                    if (strpos($result['url'], $competitor) !== false) {
                        $competitorData['position'] = $result['position'];
                        $competitorData['title'] = $result['title'];
                        $competitorData['url'] = $result['url'];
                        break;
                    }
                }
                
                $keywordData['competitors'][] = $competitorData;
            }
            
            $analysis[] = $keywordData;
            sleep(rand(3, 6));
        }
        
        return $analysis;
    }
    
    public function generateSEOReport($data, $filename = 'seo_report.json') {
        $report = [
            'generated_at' => date('Y-m-d H:i:s'),
            'summary' => [
                'total_keywords' => count($data),
                'average_position' => $this->calculateAveragePosition($data),
                'top_performing_keywords' => $this->getTopKeywords($data),
                'improvement_opportunities' => $this->getImprovementOpportunities($data)
            ],
            'detailed_data' => $data
        ];
        
        file_put_contents($filename, json_encode($report, JSON_PRETTY_PRINT));
        echo "SEO report saved to {$filename}\n";
        
        return $report;
    }
    
    private function calculateAveragePosition($data) {
        $positions = array_filter(array_column($data, 'position'));
        
        return !empty($positions) 
            ? round(array_sum($positions) / count($positions), 2)
            : 'N/A';
    }
    
    private function getTopKeywords($data, $limit = 5) {
        $filtered = array_filter($data, function($item) {
            return !is_null($item['position']);
        });
        
        usort($filtered, function($a, $b) {
            return $a['position'] - $b['position'];
        });
        
        return array_slice(array_map(function($item) {
            return [
                'keyword' => $item['keyword'],
                'position' => $item['position']
            ];
        }, $filtered), 0, $limit);
    }
    
    private function getImprovementOpportunities($data) {
        return array_map(function($item) {
            return [
                'keyword' => $item['keyword'],
                'current_position' => $item['position'] ?? 'Not ranking',
                'top_competitors' => array_slice($item['top_competitors'] ?? [], 0, 3)
            ];
        }, array_filter($data, function($item) {
            return is_null($item['position']) || $item['position'] > 10;
        }));
    }
    
    private function getRandomClient() {
        return $this->clients[array_rand($this->clients)];
    }
    
    private function getRandomUserAgent() {
        $userAgents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36'
        ];
        
        return $userAgents[array_rand($userAgents)];
    }
}

// Usage
$proxyPool = [
    ['host' => 'proxy1.nyronproxies.com', 'port' => 8000, 'user' => 'username', 'pass' => 'password'],
    ['host' => 'proxy2.nyronproxies.com', 'port' => 8000, 'user' => 'username', 'pass' => 'password']
];

$seoSuite = new SEOMonitoringSuite($proxyPool);

// Configuration
$keywords = ['seo optimization', 'rank tracking', 'serp monitoring'];
$targetDomain = 'example.com';
$competitors = ['competitor1.com', 'competitor2.com'];

echo "Starting SEO monitoring...\n";

// Track rankings
$rankings = $seoSuite->trackKeywordRankings($keywords, $targetDomain);
$seoSuite->generateSEOReport($rankings, 'ranking_report.json');

// Analyze competitors
$competitorAnalysis = $seoSuite->analyzeCompetitors($keywords, $competitors);
$seoSuite->generateSEOReport($competitorAnalysis, 'competitor_analysis.json');

echo "SEO monitoring completed!\n";
?>