Upload 6 files

README.md

@@ -1,10 +1,257 @@
----
-title: Turnstile
-emoji: 🏆
-colorFrom: red
-colorTo: yellow
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Cloudflare - Turnstile Solver NEW
+
+## 📢 Connect with Us
+
+- **📢 Channel**: [https://t.me/D3_vin](https://t.me/D3_vin) - Latest updates and releases
+- **💬 Chat**: [https://t.me/D3vin_chat](https://t.me/D3vin_chat) - Community support and discussions
+- **📁 GitHub**: [https://github.com/D3-vin](https://github.com/D3-vin) - Source code and development
+
+![Python](https://img.shields.io/badge/Python-3.6+-blue)
+![Platform](https://img.shields.io/badge/Platform-Windows%20%7C%20macOS%20%7C%20Linux-lightgrey)
+![License](https://img.shields.io/badge/License-Educational%20Use-green)
+
+
+❤️ Support the Project
+If you find this collection valuable and appreciate the effort involved in obtaining and sharing these insights, please consider supporting the project. Your contribution helps keep this resource updated and allows for further exploration.
+
+You can show your support via:
+
+Cryptocurrency:
+- **EVM:** 0xeba21af63e707ce84b76a87d0ba82140048c057e  (ETH,BNB,etc)
+- **TRON:** TEfECnyz5G1EkFrUqnbFcWLVdLvAgW9Raa
+- **TON:** UQCJ7KC2zxV_zKwLahaHf9jxy0vsWRcvQFie_FUBJW-9LcEW
+- **BTC:** bc1qdag98y5yahs6wf7rsfeh4cadsjfzmn5ngpjrcf
+- **SOL:** EwXXR4VqmWSNz1sjhZ8qcQ882i4URwAwhixSPEbDzyv6
+- **SUI:** 0x76da9b74c61508fbbd0b3e1989446e036b0622f252dd8d07c3fce759b239b47d
+
+
+🙏 Thank you for your support!
+
+A Python-based Turnstile solver using the patchright and camoufox libraries, featuring multi-threaded execution, API integration, and support for different browsers. It solves CAPTCHAs quickly and efficiently, with customizable configurations and detailed logging.
+
+## 🚀 Features
+
+- **Multi-threaded execution** - Solve multiple CAPTCHAs simultaneously
+- **Multiple browser support** - Chromium, Chrome, Edge, and Camoufox
+- **Proxy support** - Use proxies from proxies.txt file
+- **Random browser configurations** - Rotate User-Agent and Sec-CH-UA headers
+- **Detailed logging** - Comprehensive debug information
+- **REST API** - Easy integration with other applications
+- **Database storage** - SQLite database for result persistence
+- **Automatic cleanup** - Old results are automatically cleaned up
+- **Image blocking** - Optimized performance by blocking unnecessary images
+
+## 🔧 Configuration
+
+### Browser Configurations
+
+The solver supports various browser configurations with realistic User-Agent strings and Sec-CH-UA headers:
+
+- **Chrome** (versions 136-139)
+- **Edge** (versions 137-139)
+- **Avast** (versions 137-138)
+- **Brave** (versions 137-139)
+
+### Proxy Format
+
+Add proxies to `proxies.txt` in the following formats:
+
+```
+ip:port
+ip:port:username:password
+scheme://ip:port
+scheme://username:password@ip:port
+```
+
+## ❗ Disclaimers
+
+I am not responsible for anything that may happen, such as API Blocking, IP ban, etc.  
+This was a quick project that was made for fun and personal use if you want to see further updates, star the repo & create an "issue" here
+
+## ⚙️ Installation Instructions
+
+Ensure Python 3.8+ is installed on your system.
+
+### 1. Create a Python virtual environment:
+
+```bash
+python -m venv venv
+```
+
+### 2. Activate the virtual environment:
+
+**On Windows:**
+```bash
+venv\Scripts\activate
+```
+
+**On macOS/Linux:**
+```bash
+source venv/bin/activate
+```
+
+### 3. Install required dependencies:
+
+```bash
+pip install -r requirements.txt
+```
+
+### 4. Select the browser to install:
+
+You can choose between Chromium, Chrome, Edge or Camoufox:
+
+**To install Chromium:**
+```bash
+python -m patchright install chromium
+```
+
+**To install Chrome:**
+- **On macOS/Windows:** [Click here](https://www.google.com/chrome/)
+- **On Linux (Debian/Ubuntu-based):**
+```bash
+apt update
+wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
+apt install -y ./google-chrome-stable_current_amd64.deb
+apt -f install -y  # Fix dependencies if needed
+rm ./google-chrome-stable_current_amd64.deb
+```
+
+**To install Edge:**
+```bash
+python -m patchright install msedge
+```
+
+**To install Camoufox:**
+```bash
+python -m camoufox fetch
+```
+
+### 5. Start testing:
+
+Run the script (Check [🔧 Command line arguments](#-command-line-arguments) for better setup):
+
+```bash
+python api_solver.py
+```
+
+## 🔧 Command line arguments
+
+| Parameter | Default | Type | Description |
+|-----------|---------|------|-------------|
+| `--no-headless` | False | boolean | Runs the browser with GUI (disable headless mode). By default, headless mode is enabled. |
+| `--useragent` | None | string | Specifies a custom User-Agent string for the browser. (No need to set if camoufox used) |
+| `--debug` | False | boolean | Enables or disables debug mode for additional logging and troubleshooting. |
+| `--browser_type` | chromium | string | Specify the browser type for the solver. Supported options: chromium, chrome, msedge, camoufox |
+| `--thread` | 4 | integer | Sets the number of browser threads to use in multi-threaded mode. |
+| `--host` | 0.0.0.0 | string | Specifies the IP address the API solver runs on. |
+| `--port` | 6080 | integer | Sets the port the API solver listens on. |
+| `--proxy` | False | boolean | Select a random proxy from proxies.txt for solving captchas |
+| `--random` | False | boolean | Use random User-Agent and Sec-CH-UA configuration from pool |
+| `--browser` | None | string | Specify browser name to use (e.g., chrome, firefox) |
+| `--version` | None | string | Specify browser version to use (e.g., 139, 141) |
+
+## 📡 API Documentation
+
+### Solve turnstile
+
+```
+GET /turnstile?url=https://example.com&sitekey=0x4AAAAAAA
+```
+
+**Request Parameters:**
+
+| Parameter | Type | Description | Required |
+|-----------|------|-------------|----------|
+| `url` | string | The target URL containing the CAPTCHA. (e.g., https://example.com) | Yes |
+| `sitekey` | string | The site key for the CAPTCHA to be solved. (e.g., 0x4AAAAAAA) | Yes |
+| `action` | string | Action to trigger during CAPTCHA solving, e.g., login | No |
+| `cdata` | string | Custom data that can be used for additional CAPTCHA parameters. | No |
+
+**Response:**
+
+If the request is successfully received, the server will respond with a task_id for the CAPTCHA solving task:
+
+```json
+{
+  "task_id": "d2cbb257-9c37-4f9c-9bc7-1eaee72d96a8"
+}
+```
+
+### Get Result
+
+```
+GET /result?id=f0dbe75b-fa76-41ad-89aa-4d3a392040af
+```
+
+**Request Parameters:**
+
+| Parameter | Type | Description | Required |
+|-----------|------|-------------|----------|
+| `id` | string | The unique task ID returned from the /turnstile request. | Yes |
+
+**Response:**
+
+If the CAPTCHA is solved successfully, the server will respond with the following information:
+
+```json
+{
+  "status": "ready",
+  "value": "0.KBtT-r",
+  "elapsed_time": 7.625
+}
+```
+
+**Error Responses:**
+
+```json
+{
+  "status": "processing"
+}
+```
+
+```json
+{
+  "status": "fail",
+  "value": "CAPTCHA_FAIL",
+  "elapsed_time": 30.0
+}
+```
+
+
+
+## 🐛 Troubleshooting
+
+### Common Issues
+
+1. **Browser not found**: Make sure you've installed the required browser using the installation instructions
+2. **Permission denied**: Run with appropriate permissions or check file permissions
+3. **Port already in use**: Change the port using `--port` argument
+4. **Proxy connection failed**: Check proxy format and availability
+
+### Debug Mode
+
+Enable debug mode for detailed logging:
+
+```bash
+python api_solver.py --debug
+```
+
+## 📊 Performance
+
+- **Average solving time**: 5-15 seconds
+- **Success rate**: 95%+ (depending on site complexity)
+- **Memory usage**: ~50-100MB per browser thread
+- **CPU usage**: Moderate (depends on thread count)
+
+## 🤝 Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests if applicable
+5. Submit a pull request
+
+## 📄 License
+
+This project is for educational purposes only. Use at your own risk.
+

api_solver.py

@@ -0,0 +1,956 @@
+import os
+import sys
+import time
+import uuid
+import random
+import logging
+import asyncio
+from typing import Optional, Union
+import argparse
+from quart import Quart, request, jsonify
+from camoufox.async_api import AsyncCamoufox
+from patchright.async_api import async_playwright
+from db_results import init_db, save_result, load_result, cleanup_old_results
+from browser_configs import browser_config
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+from rich.align import Align
+from rich import box
+
+
+
+COLORS = {
+    'MAGENTA': '\033[35m',
+    'BLUE': '\033[34m',
+    'GREEN': '\033[32m',
+    'YELLOW': '\033[33m',
+    'RED': '\033[31m',
+    'RESET': '\033[0m',
+}
+
+
+class CustomLogger(logging.Logger):
+    @staticmethod
+    def format_message(level, color, message):
+        timestamp = time.strftime('%H:%M:%S')
+        return f"[{timestamp}] [{COLORS.get(color)}{level}{COLORS.get('RESET')}] -> {message}"
+
+    def debug(self, message, *args, **kwargs):
+        super().debug(self.format_message('DEBUG', 'MAGENTA', message), *args, **kwargs)
+
+    def info(self, message, *args, **kwargs):
+        super().info(self.format_message('INFO', 'BLUE', message), *args, **kwargs)
+
+    def success(self, message, *args, **kwargs):
+        super().info(self.format_message('SUCCESS', 'GREEN', message), *args, **kwargs)
+
+    def warning(self, message, *args, **kwargs):
+        super().warning(self.format_message('WARNING', 'YELLOW', message), *args, **kwargs)
+
+    def error(self, message, *args, **kwargs):
+        super().error(self.format_message('ERROR', 'RED', message), *args, **kwargs)
+
+
+logging.setLoggerClass(CustomLogger)
+logger = logging.getLogger("TurnstileAPIServer")
+logger.setLevel(logging.DEBUG)
+handler = logging.StreamHandler(sys.stdout)
+logger.addHandler(handler)
+
+
+class TurnstileAPIServer:
+
+    def __init__(self, headless: bool, useragent: Optional[str], debug: bool, browser_type: str, thread: int, proxy_support: bool, use_random_config: bool = False, browser_name: Optional[str] = None, browser_version: Optional[str] = None):
+        self.app = Quart(__name__)
+        self.debug = debug
+        self.browser_type = browser_type
+        self.headless = headless
+        self.thread_count = thread
+        self.proxy_support = proxy_support
+        self.browser_pool = asyncio.Queue()
+        self.use_random_config = use_random_config
+        self.browser_name = browser_name
+        self.browser_version = browser_version
+        self.console = Console()
+        
+        # Initialize useragent and sec_ch_ua attributes
+        self.useragent = useragent
+        self.sec_ch_ua = None
+        
+        
+        if self.browser_type in ['chromium', 'chrome', 'msedge']:
+            if browser_name and browser_version:
+                config = browser_config.get_browser_config(browser_name, browser_version)
+                if config:
+                    useragent, sec_ch_ua = config
+                    self.useragent = useragent
+                    self.sec_ch_ua = sec_ch_ua
+            elif useragent:
+                self.useragent = useragent
+            else:
+                browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
+                self.browser_name = browser
+                self.browser_version = version
+                self.useragent = useragent
+                self.sec_ch_ua = sec_ch_ua
+        
+        self.browser_args = []
+        if self.useragent:
+            self.browser_args.append(f"--user-agent={self.useragent}")
+
+        self._setup_routes()
+
+    def display_welcome(self):
+        """Displays welcome screen with logo."""
+        self.console.clear()
+        
+        combined_text = Text()
+        combined_text.append("\n📢 Channel: ", style="bold white")
+        combined_text.append("https://t.me/D3_vin", style="cyan")
+        combined_text.append("\n💬 Chat: ", style="bold white")
+        combined_text.append("https://t.me/D3vin_chat", style="cyan")
+        combined_text.append("\n📁 GitHub: ", style="bold white")
+        combined_text.append("https://github.com/D3-vin", style="cyan")
+        combined_text.append("\n📁 Version: ", style="bold white")
+        combined_text.append("1.2b", style="green")
+        combined_text.append("\n")
+
+        info_panel = Panel(
+            Align.left(combined_text),
+            title="[bold blue]Turnstile Solver[/bold blue]",
+            subtitle="[bold magenta]Dev by D3vin[/bold magenta]",
+            box=box.ROUNDED,
+            border_style="bright_blue",
+            padding=(0, 1),
+            width=50
+        )
+
+        self.console.print(info_panel)
+        self.console.print()
+
+
+
+
+    def _setup_routes(self) -> None:
+        """Set up the application routes."""
+        self.app.before_serving(self._startup)
+        self.app.route('/turnstile', methods=['GET'])(self.process_turnstile)
+        self.app.route('/result', methods=['GET'])(self.get_result)
+        self.app.route('/')(self.index)
+        
+
+    async def _startup(self) -> None:
+        """Initialize the browser and page pool on startup."""
+        self.display_welcome()
+        logger.info("Starting browser initialization")
+        try:
+            await init_db()
+            await self._initialize_browser()
+            
+            # Запускаем периодическую очистку старых результатов
+            asyncio.create_task(self._periodic_cleanup())
+            
+        except Exception as e:
+            logger.error(f"Failed to initialize browser: {str(e)}")
+            raise
+
+    async def _initialize_browser(self) -> None:
+        """Initialize the browser and create the page pool."""
+        playwright = None
+        camoufox = None
+
+        if self.browser_type in ['chromium', 'chrome', 'msedge']:
+            playwright = await async_playwright().start()
+        elif self.browser_type == "camoufox":
+            camoufox = AsyncCamoufox(headless=self.headless)
+
+        browser_configs = []
+        for _ in range(self.thread_count):
+            if self.browser_type in ['chromium', 'chrome', 'msedge']:
+                if self.use_random_config:
+                    browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
+                elif self.browser_name and self.browser_version:
+                    config = browser_config.get_browser_config(self.browser_name, self.browser_version)
+                    if config:
+                        useragent, sec_ch_ua = config
+                        browser = self.browser_name
+                        version = self.browser_version
+                    else:
+                        browser, version, useragent, sec_ch_ua = browser_config.get_random_browser_config(self.browser_type)
+                else:
+                    browser = getattr(self, 'browser_name', 'custom')
+                    version = getattr(self, 'browser_version', 'custom')
+                    useragent = self.useragent
+                    sec_ch_ua = getattr(self, 'sec_ch_ua', '')
+            else:
+                # Для camoufox и других браузеров используем значения по умолчанию
+                browser = self.browser_type
+                version = 'custom'
+                useragent = self.useragent
+                sec_ch_ua = getattr(self, 'sec_ch_ua', '')
+
+            
+            browser_configs.append({
+                'browser_name': browser,
+                'browser_version': version,
+                'useragent': useragent,
+                'sec_ch_ua': sec_ch_ua
+            })
+
+        for i in range(self.thread_count):
+            config = browser_configs[i]
+            
+            browser_args = []
+            if config['useragent']:
+                browser_args.append(f"--user-agent={config['useragent']}")
+            
+            browser = None
+            if self.browser_type in ['chromium', 'chrome', 'msedge'] and playwright:
+                browser = await playwright.chromium.launch(
+                    channel=self.browser_type,
+                    headless=self.headless,
+                    args=browser_args
+                )
+            elif self.browser_type == "camoufox" and camoufox:
+                browser = await camoufox.start()
+
+            if browser:
+                await self.browser_pool.put((i+1, browser, config))
+
+            if self.debug:
+                logger.info(f"Browser {i + 1} initialized successfully with {config['browser_name']} {config['browser_version']}")
+
+        logger.info(f"Browser pool initialized with {self.browser_pool.qsize()} browsers")
+        
+        if self.use_random_config:
+            logger.info(f"Each browser in pool received random configuration")
+        elif self.browser_name and self.browser_version:
+            logger.info(f"All browsers using configuration: {self.browser_name} {self.browser_version}")
+        else:
+            logger.info("Using custom configuration")
+            
+        if self.debug:
+            for i, config in enumerate(browser_configs):
+                logger.debug(f"Browser {i+1} config: {config['browser_name']} {config['browser_version']}")
+                logger.debug(f"Browser {i+1} User-Agent: {config['useragent']}")
+                logger.debug(f"Browser {i+1} Sec-CH-UA: {config['sec_ch_ua']}")
+
+    async def _periodic_cleanup(self):
+        """Periodic cleanup of old results every hour"""
+        while True:
+            try:
+                await asyncio.sleep(3600)
+                deleted_count = await cleanup_old_results(days_old=7)
+                if deleted_count > 0:
+                    logger.info(f"Cleaned up {deleted_count} old results")
+            except Exception as e:
+                logger.error(f"Error during periodic cleanup: {e}")
+
+    async def _antishadow_inject(self, page):
+        await page.add_init_script("""
+          (function() {
+            const originalAttachShadow = Element.prototype.attachShadow;
+            Element.prototype.attachShadow = function(init) {
+              const shadow = originalAttachShadow.call(this, init);
+              if (init.mode === 'closed') {
+                window.__lastClosedShadowRoot = shadow;
+              }
+              return shadow;
+            };
+          })();
+        """)
+
+
+
+    async def _optimized_route_handler(self, route):
+        """Оптимизированный обработчик маршрутов для экономии ресурсов."""
+        url = route.request.url
+        resource_type = route.request.resource_type
+
+        allowed_types = {'document', 'script', 'xhr', 'fetch'}
+
+        allowed_domains = [
+            'challenges.cloudflare.com',
+            'static.cloudflareinsights.com',
+            'cloudflare.com'
+        ]
+        
+        if resource_type in allowed_types:
+            await route.continue_()
+        elif any(domain in url for domain in allowed_domains):
+            await route.continue_() 
+        else:
+            await route.abort()
+
+    async def _block_rendering(self, page):
+        """Блокировка рендеринга для экономии ресурсов"""
+        await page.route("**/*", self._optimized_route_handler)
+
+    async def _unblock_rendering(self, page):
+        """Разблокировка рендеринга"""
+        await page.unroute("**/*", self._optimized_route_handler)
+
+    async def _find_turnstile_elements(self, page, index: int):
+        """Умная проверка всех возможных Turnstile элементов"""
+        selectors = [
+            '.cf-turnstile',
+            '[data-sitekey]',
+            'iframe[src*="turnstile"]',
+            'iframe[title*="widget"]',
+            'div[id*="turnstile"]',
+            'div[class*="turnstile"]'
+        ]
+        
+        elements = []
+        for selector in selectors:
+            try:
+                # Безопасная проверка count()
+                try:
+                    count = await page.locator(selector).count()
+                except Exception:
+                    # Если count() дает ошибку, пропускаем этот селектор
+                    continue
+                    
+                if count > 0:
+                    elements.append((selector, count))
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Found {count} elements with selector '{selector}'")
+            except Exception as e:
+                if self.debug:
+                    logger.debug(f"Browser {index}: Selector '{selector}' failed: {str(e)}")
+                continue
+        
+        return elements
+
+    async def _find_and_click_checkbox(self, page, index: int):
+        """Найти и кликнуть по чекбоксу Turnstile CAPTCHA внутри iframe"""
+        try:
+            # Пробуем разные селекторы iframe с защитой от ошибок
+            iframe_selectors = [
+                'iframe[src*="challenges.cloudflare.com"]',
+                'iframe[src*="turnstile"]',
+                'iframe[title*="widget"]'
+            ]
+            
+            iframe_locator = None
+            for selector in iframe_selectors:
+                try:
+                    test_locator = page.locator(selector).first
+                    # Безопасная проверка count для iframe
+                    try:
+                        iframe_count = await test_locator.count()
+                    except Exception:
+                        iframe_count = 0
+                        
+                    if iframe_count > 0:
+                        iframe_locator = test_locator
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Found Turnstile iframe with selector: {selector}")
+                        break
+                except Exception as e:
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Iframe selector '{selector}' failed: {str(e)}")
+                    continue
+            
+            if iframe_locator:
+                try:
+                    # Получаем frame из iframe
+                    iframe_element = await iframe_locator.element_handle()
+                    frame = await iframe_element.content_frame()
+                    
+                    if frame:
+                        # Ищем чекбокс внутри iframe
+                        checkbox_selectors = [
+                            'input[type="checkbox"]',
+                            '.cb-lb input[type="checkbox"]',
+                            'label input[type="checkbox"]'
+                        ]
+                        
+                        for selector in checkbox_selectors:
+                            try:
+                                # Полностью избегаем locator.count() в iframe - используем альтернативный подход
+                                try:
+                                    # Пробуем кликнуть напрямую без count проверки
+                                    checkbox = frame.locator(selector).first
+                                    await checkbox.click(timeout=2000)
+                                    if self.debug:
+                                        logger.debug(f"Browser {index}: Successfully clicked checkbox in iframe with selector '{selector}'")
+                                    return True
+                                except Exception as click_e:
+                                    # Если прямой клик не сработал, записываем в debug но не падаем
+                                    if self.debug:
+                                        logger.debug(f"Browser {index}: Direct checkbox click failed for '{selector}': {str(click_e)}")
+                                    continue
+                            except Exception as e:
+                                if self.debug:
+                                    logger.debug(f"Browser {index}: Iframe checkbox selector '{selector}' failed: {str(e)}")
+                                continue
+                    
+                        # Если нашли iframe, но не смогли кликнуть чекбокс, пробуем клик по iframe
+                        try:
+                            if self.debug:
+                                logger.debug(f"Browser {index}: Trying to click iframe directly as fallback")
+                            await iframe_locator.click(timeout=1000)
+                            return True
+                        except Exception as e:
+                            if self.debug:
+                                logger.debug(f"Browser {index}: Iframe direct click failed: {str(e)}")
+                
+                except Exception as e:
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Failed to access iframe content: {str(e)}")
+            
+        except Exception as e:
+            if self.debug:
+                logger.debug(f"Browser {index}: General iframe search failed: {str(e)}")
+        
+        return False
+
+    async def _try_click_strategies(self, page, index: int):
+        strategies = [
+            ('checkbox_click', lambda: self._find_and_click_checkbox(page, index)),
+            ('direct_widget', lambda: self._safe_click(page, '.cf-turnstile', index)),
+            ('iframe_click', lambda: self._safe_click(page, 'iframe[src*="turnstile"]', index)),
+            ('js_click', lambda: page.evaluate("document.querySelector('.cf-turnstile')?.click()")),
+            ('sitekey_attr', lambda: self._safe_click(page, '[data-sitekey]', index)),
+            ('any_turnstile', lambda: self._safe_click(page, '*[class*="turnstile"]', index)),
+            ('xpath_click', lambda: self._safe_click(page, "//div[@class='cf-turnstile']", index))
+        ]
+        
+        for strategy_name, strategy_func in strategies:
+            try:
+                result = await strategy_func()
+                if result is True or result is None:  # None означает успех для большинства стратегий
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Click strategy '{strategy_name}' succeeded")
+                    return True
+            except Exception as e:
+                if self.debug:
+                    logger.debug(f"Browser {index}: Click strategy '{strategy_name}' failed: {str(e)}")
+                continue
+        
+        return False
+
+    async def _safe_click(self, page, selector: str, index: int):
+        """Полностью безопасный клик с максимальной защитой от ошибок"""
+        try:
+            # Пробуем кликнуть напрямую без count() проверки
+            locator = page.locator(selector).first
+            await locator.click(timeout=1000)
+            return True
+        except Exception as e:
+            # Логируем ошибку только в debug режиме
+            if self.debug and "Can't query n-th element" not in str(e):
+                logger.debug(f"Browser {index}: Safe click failed for '{selector}': {str(e)}")
+            return False
+
+    async def _load_captcha_overlay(self, page, websiteKey: str, action: str = '', index: int = 0):
+        script = f"""
+        const existing = document.querySelector('#captcha-overlay');
+        if (existing) existing.remove();
+
+        const overlay = document.createElement('div');
+        overlay.id = 'captcha-overlay';
+        overlay.style.position = 'absolute';
+        overlay.style.top = '0';
+        overlay.style.left = '0';
+        overlay.style.width = '100vw';
+        overlay.style.height = '100vh';
+        overlay.style.backgroundColor = 'rgba(0, 0, 0, 0.5)';
+        overlay.style.display = 'block';
+        overlay.style.justifyContent = 'center';
+        overlay.style.alignItems = 'center';
+        overlay.style.zIndex = '1000';
+
+        const captchaDiv = document.createElement('div');
+        captchaDiv.className = 'cf-turnstile';
+        captchaDiv.setAttribute('data-sitekey', '{websiteKey}');
+        captchaDiv.setAttribute('data-callback', 'onCaptchaSuccess');
+        captchaDiv.setAttribute('data-action', '{action}');
+
+        overlay.appendChild(captchaDiv);
+        document.body.appendChild(overlay);
+
+        const script = document.createElement('script');
+        script.src = 'https://challenges.cloudflare.com/turnstile/v0/api.js';
+        script.async = true;
+        script.defer = true;
+        document.head.appendChild(script);
+        """
+
+        await page.evaluate(script)
+        if self.debug:
+            logger.debug(f"Browser {index}: Created CAPTCHA overlay with sitekey: {websiteKey}")
+
+    async def _solve_turnstile(self, task_id: str, url: str, sitekey: str, action: Optional[str] = None, cdata: Optional[str] = None):
+        """Solve the Turnstile challenge."""
+        proxy = None
+
+        index, browser, browser_config = await self.browser_pool.get()
+        
+        try:
+            if hasattr(browser, 'is_connected') and not browser.is_connected():
+                if self.debug:
+                    logger.warning(f"Browser {index}: Browser disconnected, skipping")
+                await self.browser_pool.put((index, browser, browser_config))
+                await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": 0})
+                return
+        except Exception as e:
+            if self.debug:
+                logger.warning(f"Browser {index}: Cannot check browser state: {str(e)}")
+
+        if self.proxy_support:
+            proxy_file_path = os.path.join(os.getcwd(), "proxies.txt")
+
+            try:
+                with open(proxy_file_path) as proxy_file:
+                    proxies = [line.strip() for line in proxy_file if line.strip()]
+
+                proxy = random.choice(proxies) if proxies else None
+                
+                if self.debug and proxy:
+                    logger.debug(f"Browser {index}: Selected proxy: {proxy}")
+                elif self.debug and not proxy:
+                    logger.debug(f"Browser {index}: No proxies available")
+                    
+            except FileNotFoundError:
+                logger.warning(f"Proxy file not found: {proxy_file_path}")
+                proxy = None
+            except Exception as e:
+                logger.error(f"Error reading proxy file: {str(e)}")
+                proxy = None
+
+            if proxy:
+                if '@' in proxy:
+                    try:
+                        scheme_part, auth_part = proxy.split('://')
+                        auth, address = auth_part.split('@')
+                        username, password = auth.split(':')
+                        ip, port = address.split(':')
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Creating context with proxy {scheme_part}://{ip}:{port} (auth: {username}:***)")
+                        context_options = {
+                            "proxy": {
+                                "server": f"{scheme_part}://{ip}:{port}",
+                                "username": username,
+                                "password": password
+                            },
+                            "user_agent": browser_config['useragent']
+                        }
+                        
+                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
+                            context_options['extra_http_headers'] = {
+                                'sec-ch-ua': browser_config['sec_ch_ua']
+                            }
+                        
+                        context = await browser.new_context(**context_options)
+                    except ValueError:
+                        raise ValueError(f"Invalid proxy format: {proxy}")
+                else:
+                    parts = proxy.split(':')
+                    if len(parts) == 5:
+                        proxy_scheme, proxy_ip, proxy_port, proxy_user, proxy_pass = parts
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Creating context with proxy {proxy_scheme}://{proxy_ip}:{proxy_port} (auth: {proxy_user}:***)")
+                        context_options = {
+                            "proxy": {
+                                "server": f"{proxy_scheme}://{proxy_ip}:{proxy_port}",
+                                "username": proxy_user,
+                                "password": proxy_pass
+                            },
+                            "user_agent": browser_config['useragent']
+                        }
+                        
+                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
+                            context_options['extra_http_headers'] = {
+                                'sec-ch-ua': browser_config['sec_ch_ua']
+                            }
+                        
+                        context = await browser.new_context(**context_options)
+                    elif len(parts) == 3:
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Creating context with proxy {proxy}")
+                        context_options = {
+                            "proxy": {"server": f"{proxy}"},
+                            "user_agent": browser_config['useragent']
+                        }
+                        
+                        if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
+                            context_options['extra_http_headers'] = {
+                                'sec-ch-ua': browser_config['sec_ch_ua']
+                            }
+                        
+                        context = await browser.new_context(**context_options)
+                    else:
+                        raise ValueError(f"Invalid proxy format: {proxy}")
+            else:
+                if self.debug:
+                    logger.debug(f"Browser {index}: Creating context without proxy")
+                context_options = {"user_agent": browser_config['useragent']}
+                
+                if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
+                    context_options['extra_http_headers'] = {
+                        'sec-ch-ua': browser_config['sec_ch_ua']
+                    }
+                
+                context = await browser.new_context(**context_options)
+        else:
+            context_options = {"user_agent": browser_config['useragent']}
+            
+            if browser_config['sec_ch_ua'] and browser_config['sec_ch_ua'].strip():
+                context_options['extra_http_headers'] = {
+                    'sec-ch-ua': browser_config['sec_ch_ua']
+                }
+            
+            context = await browser.new_context(**context_options)
+
+        page = await context.new_page()
+        
+        #await self._antishadow_inject(page)
+        
+        await self._block_rendering(page)
+        
+        #await page.add_init_script("""
+        #Object.defineProperty(navigator, 'webdriver', {
+        #    get: () => undefined,
+        #});
+        
+        #window.chrome = {
+        #    runtime: {},
+        #    loadTimes: function() {},
+        #    csi: function() {},
+        #};
+        ##""")
+        
+        if self.browser_type in ['chromium', 'chrome', 'msedge']:
+            await page.set_viewport_size({"width": 500, "height": 100})
+            if self.debug:
+                logger.debug(f"Browser {index}: Set viewport size to 500x240")
+
+        start_time = time.time()
+
+        try:
+            if self.debug:
+                logger.debug(f"Browser {index}: Starting Turnstile solve for URL: {url} with Sitekey: {sitekey} | Action: {action} | Cdata: {cdata} | Proxy: {proxy}")
+                logger.debug(f"Browser {index}: Setting up optimized page loading with resource blocking")
+
+            if self.debug:
+                logger.debug(f"Browser {index}: Loading real website directly: {url}")
+
+            await page.goto(url, wait_until='domcontentloaded', timeout=30000)
+
+            await self._unblock_rendering(page)
+
+            # Ждем немного времени для загрузки CAPTCHA
+            await asyncio.sleep(3)
+
+            locator = page.locator('input[name="cf-turnstile-response"]')
+            max_attempts = 20 
+            
+            for attempt in range(max_attempts):
+                try:
+                    # Безопасная проверка количества элементов с токеном
+                    try:
+                        count = await locator.count()
+                    except Exception as e:
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Locator count failed on attempt {attempt + 1}: {str(e)}")
+                        count = 0
+                    
+                    if count == 0:
+                        if self.debug:
+                            logger.debug(f"Browser {index}: No token elements found on attempt {attempt + 1}")
+                    elif count == 1:
+                        # Если только один элемент, проверяем его токен
+                        try:
+                            token = await locator.input_value(timeout=500)
+                            if token:
+                                elapsed_time = round(time.time() - start_time, 3)
+                                logger.success(f"Browser {index}: Successfully solved captcha - {COLORS.get('MAGENTA')}{token[:10]}{COLORS.get('RESET')} in {COLORS.get('GREEN')}{elapsed_time}{COLORS.get('RESET')} Seconds")
+                                await save_result(task_id, "turnstile", {"value": token, "elapsed_time": elapsed_time})
+                                return
+                        except Exception as e:
+                            if self.debug:
+                                logger.debug(f"Browser {index}: Single token element check failed: {str(e)}")
+                    else:
+                        # Если несколько элементов, проверяем все по очереди
+                        if self.debug:
+                            logger.debug(f"Browser {index}: Found {count} token elements, checking all")
+                        
+                        for i in range(count):
+                            try:
+                                element_token = await locator.nth(i).input_value(timeout=500)
+                                if element_token:
+                                    elapsed_time = round(time.time() - start_time, 3)
+                                    logger.success(f"Browser {index}: Successfully solved captcha - {COLORS.get('MAGENTA')}{element_token[:10]}{COLORS.get('RESET')} in {COLORS.get('GREEN')}{elapsed_time}{COLORS.get('RESET')} Seconds")
+                                    await save_result(task_id, "turnstile", {"value": element_token, "elapsed_time": elapsed_time})
+                                    return
+                            except Exception as e:
+                                if self.debug:
+                                    logger.debug(f"Browser {index}: Token element {i} check failed: {str(e)}")
+                                continue
+                    
+                    # Клик стратегии только каждые 3 попытки и не сразу
+                    if attempt > 2 and attempt % 3 == 0:
+                        click_success = await self._try_click_strategies(page, index)
+                        if not click_success and self.debug:
+                            logger.debug(f"Browser {index}: All click strategies failed on attempt {attempt + 1}")
+                    
+                    # Fallback overlay на 10 попытке если токена все еще нет
+                    if attempt == 10:
+                        try:
+                            # Безопасная проверка count для overlay
+                            try:
+                                current_count = await locator.count()
+                            except Exception:
+                                current_count = 0
+                                
+                            if current_count == 0:
+                                if self.debug:
+                                    logger.debug(f"Browser {index}: Creating overlay as fallback strategy")
+                                await self._load_captcha_overlay(page, sitekey, action or '', index)
+                                await asyncio.sleep(2)
+                        except Exception as e:
+                            if self.debug:
+                                logger.debug(f"Browser {index}: Fallback overlay creation failed: {str(e)}")
+                    
+                    # Адаптивное ожидание
+                    wait_time = min(0.5 + (attempt * 0.05), 2.0)
+                    await asyncio.sleep(wait_time)
+                    
+                    if self.debug and attempt % 5 == 0:
+                        logger.debug(f"Browser {index}: Attempt {attempt + 1}/{max_attempts} - No valid token yet")
+                        
+                except Exception as e:
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Attempt {attempt + 1} error: {str(e)}")
+                    continue
+            
+            elapsed_time = round(time.time() - start_time, 3)
+            await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": elapsed_time})
+            if self.debug:
+                logger.error(f"Browser {index}: Error solving Turnstile in {COLORS.get('RED')}{elapsed_time}{COLORS.get('RESET')} Seconds")
+        except Exception as e:
+            elapsed_time = round(time.time() - start_time, 3)
+            await save_result(task_id, "turnstile", {"value": "CAPTCHA_FAIL", "elapsed_time": elapsed_time})
+            if self.debug:
+                logger.error(f"Browser {index}: Error solving Turnstile: {str(e)}")
+        finally:
+            if self.debug:
+                logger.debug(f"Browser {index}: Closing browser context and cleaning up")
+            
+            try:
+                await context.close()
+                if self.debug:
+                    logger.debug(f"Browser {index}: Context closed successfully")
+            except Exception as e:
+                if self.debug:
+                    logger.warning(f"Browser {index}: Error closing context: {str(e)}")
+            
+            try:
+                if hasattr(browser, 'is_connected') and browser.is_connected():
+                    await self.browser_pool.put((index, browser, browser_config))
+                    if self.debug:
+                        logger.debug(f"Browser {index}: Browser returned to pool")
+                else:
+                    if self.debug:
+                        logger.warning(f"Browser {index}: Browser disconnected, not returning to pool")
+            except Exception as e:
+                if self.debug:
+                    logger.warning(f"Browser {index}: Error returning browser to pool: {str(e)}")
+
+
+
+
+
+
+    async def process_turnstile(self):
+        """Handle the /turnstile endpoint requests."""
+        url = request.args.get('url')
+        sitekey = request.args.get('sitekey')
+        action = request.args.get('action')
+        cdata = request.args.get('cdata')
+
+        if not url or not sitekey:
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_WRONG_PAGEURL",
+                "errorDescription": "Both 'url' and 'sitekey' are required"
+            }), 200
+
+        task_id = str(uuid.uuid4())
+        await save_result(task_id, "turnstile", {
+            "status": "CAPTCHA_NOT_READY",
+            "createTime": int(time.time()),
+            "url": url,
+            "sitekey": sitekey,
+            "action": action,
+            "cdata": cdata
+        })
+
+        try:
+            asyncio.create_task(self._solve_turnstile(task_id=task_id, url=url, sitekey=sitekey, action=action, cdata=cdata))
+
+            if self.debug:
+                logger.debug(f"Request completed with taskid {task_id}.")
+            return jsonify({
+                "errorId": 0,
+                "taskId": task_id
+            }), 200
+        except Exception as e:
+            logger.error(f"Unexpected error processing request: {str(e)}")
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_UNKNOWN",
+                "errorDescription": str(e)
+            }), 200
+
+    async def get_result(self):
+        """Return solved data"""
+        task_id = request.args.get('id')
+
+        if not task_id:
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_WRONG_CAPTCHA_ID",
+                "errorDescription": "Invalid task ID/Request parameter"
+            }), 200
+
+        result = await load_result(task_id)
+        if not result:
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
+                "errorDescription": "Task not found"
+            }), 200
+
+        if result == "CAPTCHA_NOT_READY" or (isinstance(result, dict) and result.get("status") == "CAPTCHA_NOT_READY"):
+            return jsonify({"status": "processing"}), 200
+
+        if isinstance(result, dict) and result.get("value") == "CAPTCHA_FAIL":
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
+                "errorDescription": "Workers could not solve the Captcha"
+            }), 200
+
+        if isinstance(result, dict) and result.get("value") and result.get("value") != "CAPTCHA_FAIL":
+            return jsonify({
+                "errorId": 0,
+                "status": "ready",
+                "solution": {
+                    "token": result["value"]
+                }
+            }), 200
+        else:
+            return jsonify({
+                "errorId": 1,
+                "errorCode": "ERROR_CAPTCHA_UNSOLVABLE",
+                "errorDescription": "Workers could not solve the Captcha"
+            }), 200
+
+    
+
+    @staticmethod
+    async def index():
+        """Serve the API documentation page."""
+        return """
+            <!DOCTYPE html>
+            <html lang="en">
+            <head>
+                <meta charset="UTF-8">
+                <meta name="viewport" content="width=device-width, initial-scale=1.0">
+                <title>Turnstile Solver API</title>
+                <script src="https://cdn.tailwindcss.com"></script>
+            </head>
+            <body class="bg-gray-900 text-gray-200 min-h-screen flex items-center justify-center">
+                <div class="bg-gray-800 p-8 rounded-lg shadow-md max-w-2xl w-full border border-red-500">
+                    <h1 class="text-3xl font-bold mb-6 text-center text-red-500">Welcome to Turnstile Solver API</h1>
+
+                    <p class="mb-4 text-gray-300">To use the turnstile service, send a GET request to 
+                       <code class="bg-red-700 text-white px-2 py-1 rounded">/turnstile</code> with the following query parameters:</p>
+
+                    <ul class="list-disc pl-6 mb-6 text-gray-300">
+                        <li><strong>url</strong>: The URL where Turnstile is to be validated</li>
+                        <li><strong>sitekey</strong>: The site key for Turnstile</li>
+                    </ul>
+
+                    <div class="bg-gray-700 p-4 rounded-lg mb-6 border border-red-500">
+                        <p class="font-semibold mb-2 text-red-400">Example usage:</p>
+                        <code class="text-sm break-all text-red-300">/turnstile?url=https://example.com&sitekey=sitekey</code>
+                    </div>
+
+
+                    <div class="bg-gray-700 p-4 rounded-lg mb-6">
+                        <p class="text-gray-200 font-semibold mb-3">📢 Connect with Us</p>
+                        <div class="space-y-2 text-sm">
+                            <p class="text-gray-300">
+                                📢 <strong>Channel:</strong> 
+                                <a href="https://t.me/D3_vin" class="text-red-300 hover:underline">https://t.me/D3_vin</a> 
+                                - Latest updates and releases
+                            </p>
+                            <p class="text-gray-300">
+                                💬 <strong>Chat:</strong> 
+                                <a href="https://t.me/D3vin_chat" class="text-red-300 hover:underline">https://t.me/D3vin_chat</a> 
+                                - Community support and discussions
+                            </p>
+                            <p class="text-gray-300">
+                                📁 <strong>GitHub:</strong> 
+                                <a href="https://github.com/D3-vin" class="text-red-300 hover:underline">https://github.com/D3-vin</a> 
+                                - Source code and development
+                            </p>
+                        </div>
+                    </div>
+                </div>
+            </body>
+            </html>
+        """
+
+
+def parse_args():
+    """Parse command-line arguments."""
+    parser = argparse.ArgumentParser(description="Turnstile API Server")
+
+    parser.add_argument('--no-headless', action='store_true', help='Run the browser with GUI (disable headless mode). By default, headless mode is enabled.')
+    parser.add_argument('--useragent', type=str, help='User-Agent string (if not specified, random configuration is used)')
+    parser.add_argument('--debug', action='store_true', help='Enable or disable debug mode for additional logging and troubleshooting information (default: False)')
+    parser.add_argument('--browser_type', type=str, default='chromium', help='Specify the browser type for the solver. Supported options: chromium, chrome, msedge, camoufox (default: chromium)')
+    parser.add_argument('--thread', type=int, default=4, help='Set the number of browser threads to use for multi-threaded mode. Increasing this will speed up execution but requires more resources (default: 1)')
+    parser.add_argument('--proxy', action='store_true', help='Enable proxy support for the solver (Default: False)')
+    parser.add_argument('--random', action='store_true', help='Use random User-Agent and Sec-CH-UA configuration from pool')
+    parser.add_argument('--browser', type=str, help='Specify browser name to use (e.g., chrome, firefox)')
+    parser.add_argument('--version', type=str, help='Specify browser version to use (e.g., 139, 141)')
+    parser.add_argument('--host', type=str, default='0.0.0.0', help='Specify the IP address where the API solver runs. (Default: 127.0.0.1)')
+    parser.add_argument('--port', type=str, default='5072', help='Set the port for the API solver to listen on. (Default: 5072)')
+    return parser.parse_args()
+
+
+def create_app(headless: bool, useragent: str, debug: bool, browser_type: str, thread: int, proxy_support: bool, use_random_config: bool, browser_name: str, browser_version: str) -> Quart:
+    server = TurnstileAPIServer(headless=headless, useragent=useragent, debug=debug, browser_type=browser_type, thread=thread, proxy_support=proxy_support, use_random_config=use_random_config, browser_name=browser_name, browser_version=browser_version)
+    return server.app
+
+
+if __name__ == '__main__':
+    args = parse_args()
+    browser_types = [
+        'chromium',
+        'chrome',
+        'msedge',
+        'camoufox',
+    ]
+    if args.browser_type not in browser_types:
+        logger.error(f"Unknown browser type: {COLORS.get('RED')}{args.browser_type}{COLORS.get('RESET')} Available browser types: {browser_types}")
+    else:
+        app = create_app(
+            headless=not args.no_headless, 
+            debug=args.debug, 
+            useragent=args.useragent, 
+            browser_type=args.browser_type, 
+            thread=args.thread, 
+            proxy_support=args.proxy,
+            use_random_config=args.random,
+            browser_name=args.browser,
+            browser_version=args.version
+        )
+        app.run(host=args.host, port=int(args.port))

browser_configs.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+"""
+Browser Configurations
+Browser configuration with User-Agent and Sec-CH-UA data for TLS fingerprinting
+"""
+
+import random
+from typing import Dict, List, Tuple, Optional
+
+
+class BrowserConfig:
+    """Class for working with browser configurations"""
+    
+    SEC_CH_UA_CONFIGS = {
+        "chrome": {
+            "139": "\"Not;A=Brand\";v=\"99\", \"Google Chrome\";v=\"139\", \"Chromium\";v=\"139\"",
+            "138": "\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Google Chrome\";v=\"138\"",
+            "137": "\"Google Chrome\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\"",
+            "136": "\"Chromium\";v=\"136\", \"Google Chrome\";v=\"136\", \"Not.A/Brand\";v=\"99\""
+        },
+        "edge": {
+            "139": "\"Not;A=Brand\";v=\"99\", \"Microsoft Edge\";v=\"139\", \"Chromium\";v=\"139\"",
+            "138": "\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Microsoft Edge\";v=\"138\"",
+            "137": "\"Microsoft Edge\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\""
+        },
+        "avast": {
+            "138": "\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Avast Secure Browser\";v=\"138\"",
+            "137": "\"Avast Secure Browser\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\""
+        },
+        "brave": {
+            "139": "\"Not;A=Brand\";v=\"99\", \"Brave\";v=\"139\", \"Chromium\";v=\"139\"",
+            "138": "\"Not)A;Brand\";v=\"8\", \"Chromium\";v=\"138\", \"Brave\";v=\"138\"",
+            "137": "\"Brave\";v=\"137\", \"Chromium\";v=\"137\", \"Not/A)Brand\";v=\"24\""
+        }
+    }
+    
+    USER_AGENT_CONFIGS = {
+        "chrome": {
+            "139": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+            "138": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+            "137": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36",
+            "136": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/136.0.0.0 Safari/537.36"
+        },
+        "edge": {
+            "139": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36 Edg/139.0.0.0",
+            "138": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Edg/138.0.0.0",
+            "137": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Edg/137.0.0.0"
+        },
+        "avast": {
+            "138": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36 Avast/138.0.0.0",
+            "137": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36 Avast/137.0.0.0"
+        },
+        "brave": {
+            "139": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+            "138": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/138.0.0.0 Safari/537.36",
+            "137": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/137.0.0.0 Safari/537.36"
+        }
+    }
+    
+    
+    def __init__(self):
+        self.available_browsers = list(self.USER_AGENT_CONFIGS.keys())
+    
+    def get_random_browser_config(self, browser_type=None) -> Tuple[str, str, str, str]:
+        """
+        Get random browser configuration
+        
+        Args:
+            browser_type: Browser type for filtering (chrome, chromium, camoufox)
+            
+        Returns:
+            Tuple[str, str, str, str]: (browser_name, version, user_agent, sec_ch_ua)
+        """
+        if browser_type in ['chrome', 'chromium', 'msedge', 'avast']:
+            chromium_browsers = ['chrome', 'edge', 'avast', 'brave']
+            browser = random.choice(chromium_browsers)
+        elif browser_type == 'camoufox':
+            return 'firefox', 'custom', '', ''
+        else:
+            browser = random.choice(self.available_browsers)
+            
+        versions = list(self.USER_AGENT_CONFIGS[browser].keys())
+        version = random.choice(versions)
+        
+        user_agent = self.USER_AGENT_CONFIGS[browser][version]
+        
+        if version in self.SEC_CH_UA_CONFIGS.get(browser, {}):
+            sec_ch_ua = self.SEC_CH_UA_CONFIGS[browser][version]
+        else:
+            sec_ch_ua = ""
+            
+        return browser, version, user_agent, sec_ch_ua
+    
+    def get_browser_config(self, browser: str, version: str) -> Optional[Tuple[str, str]]:
+
+        try:
+            user_agent = self.USER_AGENT_CONFIGS[browser][version]
+            
+            if version in self.SEC_CH_UA_CONFIGS.get(browser, {}):
+                sec_ch_ua = self.SEC_CH_UA_CONFIGS[browser][version]
+            else:
+                sec_ch_ua = ""
+                
+            return user_agent, sec_ch_ua
+        except KeyError:
+            return None
+    
+    def get_all_configs(self) -> List[Tuple[str, str, str, str]]:
+
+        configs = []
+        for browser in self.available_browsers:
+            for version in self.USER_AGENT_CONFIGS[browser].keys():
+                user_agent = self.USER_AGENT_CONFIGS[browser][version]
+                
+                if version in self.SEC_CH_UA_CONFIGS.get(browser, {}):
+                    sec_ch_ua = self.SEC_CH_UA_CONFIGS[browser][version]
+                else:
+                    sec_ch_ua = ""
+                    
+                configs.append((browser, version, user_agent, sec_ch_ua))
+        
+        return configs
+    
+    def get_browser_versions(self, browser: str) -> List[str]:
+
+        return list(self.USER_AGENT_CONFIGS.get(browser, {}).keys())
+    
+    def get_available_browsers(self) -> List[str]:
+
+        return self.available_browsers.copy()
+    
+    def print_all_configs(self):
+        """Print all available configurations to console"""
+        print("=== AVAILABLE BROWSER CONFIGURATIONS ===\n")
+        
+        for browser in self.available_browsers:
+            print(f"🌐 {browser.upper()}:")
+            for version in self.USER_AGENT_CONFIGS[browser].keys():
+                user_agent = self.USER_AGENT_CONFIGS[browser][version]
+                
+                if version in self.SEC_CH_UA_CONFIGS.get(browser, {}):
+                    sec_ch_ua = self.SEC_CH_UA_CONFIGS[browser][version]
+                else:
+                    sec_ch_ua = "NOT SUPPORTED"
+                    
+                print(f"  📱 Version {version}:")
+                print(f"    User-Agent: {user_agent}")
+                print(f"    Sec-CH-UA: {sec_ch_ua}")
+                print()
+            print("-" * 50)
+
+
+browser_config = BrowserConfig()
+
+
+if __name__ == '__main__':
+    config = BrowserConfig()
+    
+    print("🎯 Random configuration:")
+    browser, version, ua, sec_ua = config.get_random_browser_config()
+    print(f"Browser: {browser} {version}")
+    print(f"User-Agent: {ua}")
+    print(f"Sec-CH-UA: {sec_ua}")
+    print()
+    
+    print("📋 All available browsers:")
+    for browser in config.get_available_browsers():
+        versions = config.get_browser_versions(browser)
+        print(f"  {browser}: {', '.join(versions)}")
+    print()
+    
+    config.print_all_configs()

db_results.py

@@ -0,0 +1,134 @@
+import aiosqlite
+import json
+import logging
+from typing import Dict, Any, Optional, Union
+
+DB_PATH = "results.db"
+
+# PRAGMA настройки для оптимизации БД
+PRAGMA_SETTINGS = [
+    "PRAGMA journal_mode=WAL",
+    "PRAGMA synchronous=NORMAL", 
+    "PRAGMA cache_size=10000",
+    "PRAGMA temp_store=MEMORY",
+    "PRAGMA busy_timeout=30000"
+]
+
+async def _apply_pragma_settings(db):
+    """Применить PRAGMA настройки к подключению БД"""
+    for pragma in PRAGMA_SETTINGS:
+        await db.execute(pragma)
+
+async def init_db():
+    """Initialize database with results table in WAL mode"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            await db.execute("""
+                CREATE TABLE IF NOT EXISTS results (
+                    task_id TEXT PRIMARY KEY,
+                    type TEXT NOT NULL,
+                    data TEXT NOT NULL,
+                    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            await db.commit()
+            logging.getLogger("TurnstileAPIServer").info(f"Database initialized in WAL mode: {DB_PATH}")
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Database initialization error: {e}")
+        raise
+
+async def save_result(task_id: str, task_type: str, data: Union[Dict[str, Any], str]) -> None:
+    """Save result to database"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            data_json = json.dumps(data) if isinstance(data, dict) else data
+            
+            await db.execute(
+                "REPLACE INTO results (task_id, type, data) VALUES (?, ?, ?)",
+                (task_id, task_type, data_json)
+            )
+            await db.commit()
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error saving result {task_id}: {e}")
+        raise
+
+async def load_result(task_id: str) -> Optional[Union[Dict[str, Any], str]]:
+    """Load result from database"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            async with db.execute("SELECT data FROM results WHERE task_id = ?", (task_id,)) as cursor:
+                row = await cursor.fetchone()
+                if row:
+                    try:
+                        return json.loads(row[0])
+                    except json.JSONDecodeError:
+                        return row[0]
+        return None
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error loading result {task_id}: {e}")
+        return None
+
+async def load_all_results() -> Dict[str, Any]:
+    """Load all results from database"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            results = {}
+            async with db.execute("SELECT task_id, data FROM results") as cursor:
+                async for row in cursor:
+                    try:
+                        results[row[0]] = json.loads(row[1])
+                    except json.JSONDecodeError:
+                        results[row[0]] = row[1]
+            return results
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error loading all results: {e}")
+        return {}
+
+async def delete_result(task_id: str) -> None:
+    """Delete result from database"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            await db.execute("DELETE FROM results WHERE task_id = ?", (task_id,))
+            await db.commit()
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error deleting result {task_id}: {e}")
+
+async def get_pending_count() -> int:
+    """Get count of pending tasks"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            async with db.execute("SELECT COUNT(*) FROM results WHERE data LIKE '%CAPTCHA_NOT_READY%'") as cursor:
+                row = await cursor.fetchone()
+                return row[0] if row else 0
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error getting pending count: {e}")
+        return 0
+
+async def cleanup_old_results(days_old: int = 1) -> int:
+    """Clean up results older than specified days"""
+    try:
+        async with aiosqlite.connect(DB_PATH) as db:
+            await _apply_pragma_settings(db)
+            
+            async with db.execute(
+                "DELETE FROM results WHERE created_at < datetime('now', '-{} days')".format(days_old)
+            ) as cursor:
+                deleted_count = cursor.rowcount
+                await db.commit()
+                logging.getLogger("TurnstileAPIServer").info(f"Cleaned up {deleted_count} old results")
+                return deleted_count
+    except Exception as e:
+        logging.getLogger("TurnstileAPIServer").error(f"Error cleaning up old results: {e}")
+        return 0

requirements.txt

@@ -0,0 +1,8 @@
+quart
+asyncio
+argparse
+patchright
+camoufox[geoip]
+requests
+aiosqlite
+rich