Python web Traffic Yazılımı Ücretsiz

Merhabalar arkadaşlar , Daha önce kullandığım pyhon ile yazılmış Google Analytics e tamı tamına yansıyan kodlarımı veriyorum, artık kullanmıyorum requestte gectiğim için.

import asyncio
from playwright.async_api import async_playwright
import random
import time
import logging
import argparse
import os
import sys
import subprocess
import json
from datetime import datetime
from urllib.parse import urlparse
import ssl


ssl._create_default_https_context = ssl._create_unverified_context

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s - %(levelname)s - %(message)s',
    handlers=[
        logging.FileHandler(f"analytics_traffic_{datetime.now().strftime('%Y%m%d_%H%M%S')}.log", encoding='utf-8'),
        logging.StreamHandler()
    ]
)
logger = logging.getLogger()

class ProxyManager:
    def __init__(self, proxy_file):
        """
        
        Args:
            proxy_file (str): Proxy dosyasının yolu
        """
        self.proxy_file = proxy_file
        self.proxies = []
        self.working_proxies = []  
        self.load_proxies()
        
        if not self.proxies:
            logger.error(f"Proxy bulunamadi! Lutfen {proxy_file} dosyasini kontrol edin.")
            raise FileNotFoundError(f"Proxy dosyası bulunamadı veya boş: {proxy_file}")
    
    def load_proxies(self):
        """Dosyadan proxy'leri yükler"""
        try:
            with open(self.proxy_file, 'r') as file:
                for line in file:
                    line = line.strip()
                    if line:
                        try:
                          
                            parts = line.split(':')
                            if len(parts) >= 4:
                                host = parts[0]
                                port = parts[1]
                                username = parts[2]
                                password = ':'.join(parts[3:])  
                                
                                
                                self.proxies.append({
                                    "server": f"http://{host}:{port}",
                                    "username": username,
                                    "password": password,
                                    "original": line
                                })
                            else:
                                logger.warning(f"Gecersiz proxy formati: {line}")
                        except Exception as e:
                            logger.error(f"Proxy ayristirma hatasi: {e} - Satir: {line}")
            
            logger.info(f"Toplam {len(self.proxies)} proxy okundu.")
            
            
            self.working_proxies = self.proxies
            
        except Exception as e:
            logger.error(f"Dosya okuma hatasi: {e}")
    
    async def test_proxies(self, max_test=10):
        """
        
        """
        logger.info("Proxy testi atlanıyor, tüm proxy'lerin çalıştığı varsayılıyor...")
        # Tüm proxy'lerin çalıştığını varsay
        self.working_proxies = self.proxies
    
    def get_random_proxy(self):
        """Rastgele bir proxy döndürür"""
        if not self.proxies:
            return None
        return random.choice(self.proxies)
    
    def get_proxies_for_sessions(self, num_sessions):
      
        if len(self.proxies) < num_sessions:
            # Proxy sayısı yetersizse, tekrar kullan
            return [self.proxies[i % len(self.proxies)] for i in range(num_sessions)]
        else:
            # Rastgele num_sessions kadar proxy seç
            return random.sample(self.proxies, num_sessions)
    
    def mask_proxy_url(self, proxy_info):
      
        if not proxy_info:
            return "Proxy yok"
        
        try:
            server = proxy_info["server"]
            username = proxy_info["username"]
            
            
            masked_username = username[:3] + '*' * (len(username) - 3) if len(username) > 3 else username
            
            
            parsed = urlparse(server)
            host_port = f"{parsed.netloc}"
            
            return f"{parsed.scheme}://{masked_username}:******@{host_port}"
        except:
            return str(proxy_info)

class UserAgentManager:
    def __init__(self):
        """User-Agent yönetim sınıfı""
        self.user_agents = [
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:89.0) Gecko/20100101 Firefox/89.0',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/14.1.1 Safari/605.1.15',
            'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.101 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:90.0) Gecko/20100101 Firefox/90.0',
            'Mozilla/5.0 (Macintosh; Intel Mac OS X 10.15; rv:90.0) Gecko/20100101 Firefox/90.0',
            'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/92.0.4515.107 Safari/537.36 Edg/92.0.902.55'
        ]
        
        
        try:
            from fake_useragent import UserAgent
            self.ua = UserAgent()
            logger.info("Fake UserAgent basariyla baslatildi.")
            self.has_fake_ua = True
        except Exception as e:
            logger.warning(f"Fake UserAgent baslatma hatasi: {e}")
            logger.warning("Onceden tanimlanmis user agent'lar kullanilacak.")
            self.has_fake_ua = False
    
    def get_random_user_agent(self):
        """Rastgele bir User-Agent döndürür"""
        if hasattr(self, 'has_fake_ua') and self.has_fake_ua:
            try:
                return self.ua.random
            except:
                pass
        return random.choice(self.user_agents)

class PlaywrightManager:
    def __init__(self, target_urls, proxy_file, num_sessions=2000, visit_duration=60, page_interaction=True, browser_type="all"):
        """
        
        
        Args:
            target_urls (list): Ziyaret edilecek URL'ler listesi
            proxy_file (str): Proxy dosyasının yolu
            num_sessions (int): Oturum sayısı
            visit_duration (int): Her sayfada kalma süresi (saniye)
            page_interaction (bool): Sayfa ile etkileşim kurulsun mu?
            browser_type (str): Kullanılacak tarayıcı tipi ("all", "chromium", "firefox", "webkit")
        """
        self.target_urls = target_urls if isinstance(target_urls, list) else [target_urls]
        self.proxy_manager = ProxyManager(proxy_file)
        self.ua_manager = UserAgentManager()
        self.num_sessions = num_sessions
        self.visit_duration = visit_duration
        self.page_interaction = page_interaction
        self.browser_type = browser_type
        self.session_stats = {i: {"success": 0, "failed": 0} for i in range(num_sessions)}
        self.total_visits = 0
        self.start_time = None
        self.browsers = []
        self.tasks = []
    
    async def check_playwright_browsers(self):
      
        try:
            # Tarayıcıların kurulu olup olmadığını kontrol et
            result = subprocess.run(
                ["playwright", "install", "--dry-run"],
                capture_output=True,
                text=True
            )
            
          
            if "Browsers are already installed" not in result.stdout:
                logger.warning("Playwright tarayıcıları kurulu değil!")
                logger.info("Tarayıcılar indiriliyor... Bu işlem birkaç dakika sürebilir.")
                
                install_process = subprocess.run(
                    ["playwright", "install"],
                    capture_output=True,
                    text=True
                )
                
                if install_process.returncode == 0:
                    logger.info("Tarayıcılar başarıyla kuruldu!")
                else:
                    logger.error("Tarayıcı kurulumu başarısız oldu!")
                    logger.error(install_process.stderr)
                    logger.info("Lütfen manuel olarak 'playwright install' komutunu çalıştırın.")
                    sys.exit(1)
            else:
                logger.info("Playwright tarayıcıları zaten kurulu.")
        
        except Exception as e:
            logger.error(f"Tarayıcı kontrolü sırasında hata: {e}")
            logger.info("Lütfen manuel olarak 'playwright install' komutunu çalıştırın.")
            sys.exit(1)
    
    async def setup_browser(self, playwright, proxy_info, user_agent, session_id):
        """
        
        
        Args:
            playwright: Playwright nesnesi
            proxy_info (dict): Proxy bilgileri
            user_agent (str): User-Agent
            session_id (int): Oturum ID'si
        
        Returns:
            tuple: (browser, context) tarayıcı ve bağlam nesneleri
        """
        try:
            # Tarayıcı tipini seç
            if self.browser_type == "all":
                browser_types = ["chromium", "firefox", "webkit"]
                browser_weights = [0.7, 0.2, 0.1]  # Chromium daha yaygın
                browser_type = random.choices(browser_types, weights=browser_weights, k=1)[0]
            else:
                browser_type = self.browser_type
            
            l
            if browser_type == "chromium":
                browser_obj = playwright.chromium
            elif browser_type == "firefox":
                browser_obj = playwright.firefox
            else:
                browser_obj = playwright.webkit
            
            
            browser = await browser_obj.launch(
                headless=True,  # Görünmez modda çalıştır
                slow_mo=50,     # İşlemleri yavaşlat (ms)
                args=[
                    '--disable-extensions',
                    '--disable-gpu',
                    '--disable-dev-shm-usage',
                    '--no-sandbox',
                    '--disable-web-security'
                ]
            )
            
            
            context = await browser.new_context(
                proxy={
                    "server": proxy_info["server"],
                    "username": proxy_info["username"],
                    "password": proxy_info["password"]
                },
                user_agent=user_agent,
                viewport={"width": 1366, "height": 768},
                locale="tr-TR",  # Türkçe dil ayarı
                timezone_id="Europe/Istanbul",  # Türkiye zaman dilimi
                geolocation={"latitude": 31.995408, "longitude": 36.544443},  # İstanbul konumu
                permissions=["geolocation", "notifications"]  # İzinler
            )
            
            
            await context.add_init_script("""
                Object.defineProperty(navigator, 'webdriver', {
                    get: () => false,
                });
            """)
            
            logger.info(f"Oturum #{session_id+1} - {browser_type.capitalize()} tarayıcı başlatıldı")
            return browser, context
        
        except Exception as e:
            logger.error(f"Oturum #{session_id+1} - Tarayıcı başlatma hatası: {e}")
            return None, None
    
    async def interact_with_page(self, page):
        """
        Sayfa ile etkileşim kurar (scroll, tıklama vb.)
        
        Args:
            page: Playwright page nesnesi
        """
        try:
          
            for _ in range(random.randint(2, 5)):
                await page.evaluate("window.scrollBy(0, window.innerHeight / 2)")
                await asyncio.sleep(random.uniform(1, 2))
            
            
            await page.evaluate("window.scrollTo(0, 0)")
            await asyncio.sleep(random.uniform(0.5, 1))
            
          
            try:
                links = await page.query_selector_all('a[href^="/"], a[href^="http"]')
                if links and random.random() < 0.3:  # %30 ihtimalle bir linke tıkla
                    random_link = random.choice(links)
                    try:
                      
                        async with page.expect_navigation(timeout=10000, wait_until="domcontentloaded"):
                            await random_link.click()
                        
                      
                        await asyncio.sleep(random.uniform(3, 5))
                        
                      
                        await page.go_back()
                        await asyncio.sleep(random.uniform(1, 2))
                    except Exception as e:
                        logger.debug(f"Link tıklama hatası: {e}")
            except Exception as e:
                logger.debug(f"Link seçme hatası: {e}")
        
        except Exception as e:
            logger.debug(f"Sayfa etkileşim hatası: {e}")
    
    async def custom_page_load_strategy(self, page, url):
        """
        
        
        Args:
            page: Playwright page nesnesi
            url (str): Ziyaret edilecek URL
            
        Returns:
            bool: Başarılı ise True, değilse False
        """
        try:
            # Temel navigasyon - minimum bekleme ile
            await page.goto(url, wait_until="commit", timeout=20000)
            
            
            for _ in range(30):  # Maksimum 30 saniye bekle
                # Sayfa hazır mı kontrol et
                is_ready = await page.evaluate("""() => {
                    return document.readyState === 'complete' || document.readyState === 'interactive';
                }""")
                
                if is_ready:
                    
                    has_content = await page.evaluate("""() => {
                        return !!document.querySelector('body') &&
                               document.body.innerHTML.length > 500;
                    }""")
                    
                    if has_content:
                        return True
                
                # 1 saniye bekle ve tekrar dene
                await asyncio.sleep(1)
            
            return False
        except Exception as e:
            logger.error(f"Özel yükleme stratejisi hatası: {e}")
            return False
    
    async def visit_url(self, context, url, session_id):
        """
        Belirtilen URL'yi ziyaret eder - İyileştirilmiş sürüm
        
        Args:
            context: Playwright context nesnesi
            url (str): Ziyaret edilecek URL
            session_id (int): Oturum ID'si
        
        Returns:
            bool: Başarılı ise True, değilse False
        """
        try:
            # Yeni sayfa oluştur
            page = await context.new_page()
            
            
            start_time = time.time()
            
            i
            try:
                
                response = await page.goto(
                    url,
                    wait_until="domcontentloaded",
                    timeout=40000
                )
            except Exception as e:
                logger.warning(f"Oturum #{session_id+1} - domcontentloaded ile yükleme başarısız: {e}")
                # Başarısız olursa, commit ile dene
                try:
                    response = await page.goto(
                        url,
                        wait_until="commit",
                        timeout=20000
                    )
                except Exception as e2:
                    logger.error(f"Oturum #{session_id+1} - Sayfa yükleme tamamen başarısız: {e2}")
                    self.session_stats[session_id]["failed"] += 1
                    await page.close()
                    return False
            
            # Yükleme süresini hesapla
            load_time = time.time() - start_time
            
            if not response:
                logger.warning(f"Oturum #{session_id+1} - Yanıt alınamadı: {url}")
                self.session_stats[session_id]["failed"] += 1
                await page.close()
                return False
            
            status = response.status
            
            if 200 <= status < 400:
                # Sayfa başlığını al
                title = await page.title()
                
                logger.info(f"Oturum #{session_id+1} - Başarılı ziyaret - {url} - Durum: {status} - Yükleme: {load_time:.2f}s - Başlık: {title}")
                
                # Sayfanın yüklenmesi için ek bekleme
                try:
                    # Sayfa içeriğinin görünür olmasını bekle
                    await page.wait_for_selector('body', timeout=10000)
                    
                    # Sayfanın stabil olması için biraz bekle
                    await asyncio.sleep(3)
                except Exception as e:
                    logger.warning(f"Oturum #{session_id+1} - Sayfa içeriği bekleme hatası: {e}")
                
                
                await asyncio.sleep(3)
                
              
                if self.page_interaction:
                    await self.interact_with_page(page)
                
                
                await asyncio.sleep(self.visit_duration)
                
              
                try:
                    has_analytics = await page.evaluate("""() => {
                        return !!(
                            window.ga ||
                            window.gtag ||
                            window.dataLayer ||
                            window.google_tag_manager ||
                            document.querySelector('script[src*="google-analytics.com"]') ||
                            document.querySelector('script[src*="googletagmanager.com"]')
                        );
                    }""", timeout=5000)
                    
                    if has_analytics:
                        logger.info(f"Oturum #{session_id+1} - Google Analytics tespit edildi: {url}")
                except Exception as e:
                    logger.debug(f"Oturum #{session_id+1} - Analytics kontrolü hatası: {e}")
                
                self.session_stats[session_id]["success"] += 1
                await page.close()
                return True
            else:
                logger.warning(f"Oturum #{session_id+1} - Başarısız ziyaret - {url} - Durum: {status}")
                self.session_stats[session_id]["failed"] += 1
                await page.close()
                return False
        
        except Exception as e:
            logger.error(f"Oturum #{session_id+1} - Ziyaret hatası - {url}: {e}")
            self.session_stats[session_id]["failed"] += 1
            return False
    
    async def run_session(self, playwright, session_id):
        """
        Bir oturumu çalıştırır
        
        Args:
            playwright: Playwright nesnesi
            session_id (int): Oturum ID'si
        """
        # Proxy ve User-Agent seç
        proxy_info = self.proxy_manager.get_random_proxy()
        user_agent = self.ua_manager.get_random_user_agent()
        
        if not proxy_info:
            logger.error(f"Oturum #{session_id+1} - Proxy bulunamadı!")
            return
        
      
        masked_proxy = self.proxy_manager.mask_proxy_url(proxy_info)
        logger.info(f"Oturum #{session_id+1} - Proxy: {masked_proxy}")
        
      
        browser, context = await self.setup_browser(playwright, proxy_info, user_agent, session_id)
        
        if not browser or not context:
            return
        
        self.browsers.append((browser, context))
        
        try:
            
            for url in self.target_urls:
                success = await self.visit_url(context, url, session_id)
                self.total_visits += 1
                
              
                if success and len(self.target_urls) > 1:
                    await asyncio.sleep(random.uniform(3, 8))
        
        except Exception as e:
            logger.error(f"Oturum #{session_id+1} - Çalışma hatası: {e}")
        
        finally:
            
            try:
                await context.close()
                await browser.close()
                logger.info(f"Oturum #{session_id+1} - Tarayıcı kapatıldı")
            except:
                pass
    
    async def run_all_sessions(self):
        """Tüm oturumları çalıştırır"""
        self.start_time = time.time()
        
        # Tarayıcıların kurulu olup olmadığını kontrol et
        await self.check_playwright_browsers()
        
        # Proxy test etme adımını atla - tüm proxy'lerin çalıştığını varsay
        logger.info("Proxy testi atlanıyor, tüm proxy'lerin çalıştığı varsayılıyor...")
        
        async with async_playwright() as playwright:
            # Tüm oturumları başlat
            self.tasks = []
            for i in range(self.num_sessions):
                # Oturumlar arasında kısa bir gecikme ekle (aynı anda çok fazla tarayıcı başlatmamak için)
                await asyncio.sleep(random.uniform(1, 3))
                task = asyncio.create_task(self.run_session(playwright, i))
                self.tasks.append(task)
            
            # Tüm görevlerin tamamlanmasını bekle
            await asyncio.gather(*self.tasks, return_exceptions=True)
        
        # İstatistikleri göster
        self.show_stats()
    
    def show_stats(self):
        """İstatistikleri gösterir"""
        end_time = time.time()
        elapsed_time = end_time - self.start_time
        
        logger.info("\n--- İstatistikler ---")
        logger.info(f"Toplam çalışma süresi: {elapsed_time:.2f} saniye")
        logger.info(f"Toplam ziyaret sayısı: {self.total_visits}")
        
        total_success = sum(stats["success"] for stats in self.session_stats.values())
        total_failed = sum(stats["failed"] for stats in self.session_stats.values())
        
        if self.total_visits > 0:
            success_rate = total_success / self.total_visits * 100
            logger.info(f"Başarılı ziyaretler: {total_success} ({success_rate:.2f}%)")
            logger.info(f"Başarısız ziyaretler: {total_failed} ({100 - success_rate:.2f}%)")
        
        # Oturum bazında istatistikleri göster
        logger.info("\nOturum bazında istatistikler:")
        for session_id, stats in self.session_stats.items():
            total = stats["success"] + stats["failed"]
            success_rate = stats["success"] / total * 100 if total > 0 else 0
            logger.info(f"Oturum #{session_id+1} - Başarılı: {stats['success']}, Başarısız: {stats['failed']}, Başarı oranı: {success_rate:.2f}%")
    
    async def save_results_to_csv(self, filename="analytics_results.csv"):
        """Sonuçları CSV dosyasına kaydeder"""
        import csv
        
        try:
            with open(filename, 'w', newline='', encoding='utf-8') as csvfile:
                fieldnames = ['session_id', 'success', 'failed', 'success_rate']
                writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
                
                writer.writeheader()
                for session_id, stats in self.session_stats.items():
                    total = stats["success"] + stats["failed"]
                    success_rate = stats["success"] / total * 100 if total > 0 else 0
                    
                    writer.writerow({
                        'session_id': session_id + 1,
                        'success': stats["success"],
                        'failed': stats["failed"],
                        'success_rate': f"{success_rate:.2f}%"
                    })
                
                logger.info(f"Sonuçlar {filename} dosyasına kaydedildi.")
        except Exception as e:
            logger.error(f"CSV kaydetme hatası: {e}")

async def main():
    # Argüman ayrıştırıcı
    parser = argparse.ArgumentParser(description='Playwright ile web sitesi ziyareti ve Google Analytics\'e veri gönderme')
    parser.add_argument('--urls', type=str, help='Ziyaret edilecek URL\'ler (virgülle ayrılmış)')
    parser.add_argument('--proxy-file', type=str, default='proxy.txt', help='Proxy dosyası (varsayılan: proxy.txt)')
    parser.add_argument('--sessions', type=int, default=20000, help='Oturum sayısı (varsayılan: 5)')
    parser.add_argument('--duration', type=int, default=30, help='Her sayfada kalma süresi saniye (varsayılan: 30)')
    parser.add_argument('--no-interaction', action='store_true', help='Sayfa ile etkileşim kurma')
    parser.add_argument('--browser', type=str, default='chromium', choices=['all', 'chromium', 'firefox', 'webkit'],
                        help='Kullanılacak tarayıcı (varsayılan: chromium)')
    parser.add_argument('--csv', type=str, help='Sonuçları CSV dosyasına kaydet')
    
    args = parser.parse_args()
    
    # URL'leri al
    if args.urls:
        target_urls = [url.strip() for url in args.urls.split(',')]
    else:
        target_urls = input("Ziyaret edilecek URL'leri girin (virgülle ayırarak): ").split(',')
        target_urls = [url.strip() for url in target_urls]
    
    # URL formatını kontrol et
    for i, url in enumerate(target_urls):
        if not url.startswith(('http://', 'https://')):
            target_urls[i] = 'https://' + url
    
    # Proxy dosyasını kontrol et
    proxy_file = args.proxy_file
    if not os.path.exists(proxy_file):
        logger.error(f"{proxy_file} dosyası bulunamadı!")
        # Örnek proxy.txt oluştur
        logger.info("Örnek proxy.txt dosyası oluşturuluyor...")
        with open(proxy_file, 'w') as f:
            f.write("rotating2.we1.town:1000005:5112e6eee4b8e8d28ac3b8__cr.tr:e4f98ea6ff6763a0c\n")
        logger.info(f"{proxy_file} dosyası oluşturuldu.")
    
    # Ayarlar
    num_sessions = args.sessions
    visit_duration = args.duration
    page_interaction = not args.no_interaction
    browser_type = args.browser
    
    # Uyarı mesajı
    logger.warning("\n" + "!" * 80)
    logger.warning("UYARI: Bu script web sitelerine gerçek tarayıcı trafiği gönderecektir!")
    logger.warning(f"- Hedef URL'ler: {', '.join(target_urls)}")
    logger.warning(f"- {num_sessions} oturum aynı anda çalışacak")
    logger.warning(f"- Her sayfa ziyareti yaklaşık {visit_duration} saniye sürecek")
    logger.warning(f"- Sayfa etkileşimi: {'Açık' if page_interaction else 'Kapalı'}")
    logger.warning(f"- Tarayıcı tipi: {browser_type}")
    logger.warning("Bu, hedef sitelere yük bindirebilir ve IP adresinizin engellenmesine neden olabilir.")
    logger.warning("Sadece izin verilen sitelerde ve test amaçlı kullanın!")
    logger.warning("!" * 80 + "\n")
    
    # Kullanıcı onayı
    try:
        input("Devam etmek için Enter tuşuna basın (İptal etmek için Ctrl+C)...")
    except KeyboardInterrupt:
        logger.info("İşlem iptal edildi.")
        return
    
    # Playwright ile web sitesi ziyareti
    manager = PlaywrightManager(
        target_urls=target_urls,
        proxy_file=proxy_file,
        num_sessions=num_sessions,
        visit_duration=visit_duration,
        page_interaction=page_interaction,
        browser_type=browser_type
    )
    
    # Tüm oturumları çalıştır
    await manager.run_all_sessions()
    
    # Sonuçları CSV'ye kaydet
    if args.csv:
        await manager.save_results_to_csv(args.csv)

if __name__ == "__main__":
    # Ana fonksiyonu çalıştır
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        logger.info("Program kullanıcı tarafından durduruldu.")
    except Exception as e:
        logger.error(f"Beklenmeyen hata: {e}")

İsteyen olursa elbette bir üst süümünü kurabilirim görsel arayüzü de var direk traffic de sağlayabilirsiniz isterseniz google üzerinden anahtar kelimeyle de arama yapabilirsiniz çok çüz i miktarlara açık kaynak olarak kurabilirim