Playwright V2: Bypassed Every Anti-Bot System

import asyncio
from playwright.async_api import async_playwright
import random
import fingerprint_generator

class StealthBrowser:
    """
    Playwright with advanced anti-detection
    """

    def __init__(self):
        self.fingerprint = fingerprint_generator.generate()

    async def start(self):
        self.playwright = await async_playwright().start()

        # Launch with stealth options
        self.browser = await self.playwright.chromium.launch(
            headless=False,  # Headless gets detected more
            args=self._get_stealth_args(),
            channel=self._get_browser_channel()  # Use installed Chrome
        )

        # Create context with spoofed fingerprint
        self.context = await self.browser.new_context(
            viewport=self.fingerprint['viewport'],
            user_agent=self.fingerprint['user_agent'],
            locale=self.fingerprint['locale'],
            timezone_id=self.fingerprint['timezone'],
            geolocation=self.fingerprint['geolocation'],
            permissions=['geolocation'],
            color_scheme=self.fingerprint['color_scheme'],
            device_scale_factor=self.fingerprint['dpr'],
        )

        # Inject stealth scripts
        await self.context.add_init_script("""
            // Override navigator properties
            Object.defineProperty(navigator, 'webdriver', {
                get: () => undefined
            });

            // Override Chrome detection
            window.chrome = {
                runtime: {},
                loadTimes: function() {},
                csi: function() {},
                app: {}
            };

            // Override permissions API
            const originalQuery = window.navigator.permissions.query;
            window.navigator.permissions.query = (parameters) => (
                parameters.name === 'notifications' ?
                    Promise.resolve({ state: Notification.permission }) :
                    originalQuery(parameters)
            );

            // WebGL spoofing
            const getParameter = WebGLRenderingContext.prototype.getParameter;
            WebGLRenderingContext.prototype.getParameter = function(parameter) {
                if (parameter === 37445) {
                    return 'Intel Inc.';
                }
                if (parameter === 37446) {
                    return 'Intel Iris OpenGL Engine';
                }
                return getParameter.call(this, parameter);
            };

            // Canvas fingerprint randomization
            const originalToDataURL = HTMLCanvasElement.prototype.toDataURL;
            HTMLCanvasElement.prototype.toDataURL = function(type) {
                const context = this.getContext('2d');
                if (context) {
                    const imageData = context.getImageData(0, 0, this.width, this.height);
                    for (let i = 0; i < imageData.data.length; i += 4) {
                        imageData.data[i] = imageData.data[i] + Math.floor(Math.random() * 3) - 1;
                    }
                    context.putImageData(imageData, 0, 0);
                }
                return originalToDataURL.apply(this, arguments);
            };

            // AudioContext spoofing
            const audioContext = window.AudioContext || window.webkitAudioContext;
            if (audioContext) {
                const originalCreateAnalyser = audioContext.prototype.createAnalyser;
                audioContext.prototype.createAnalyser = function() {
                    const analyser = originalCreateAnalyser.call(this);
                    const originalGetFloatFrequencyData = analyser.getFloatFrequencyData;
                    analyser.getFloatFrequencyData = function(array) {
                        originalGetFloatFrequencyData.call(this, array);
                        for (let i = 0; i < array.length; i++) {
                            array[i] = array[i] + Math.random() * 0.0001;
                        }
                    };
                    return analyser;
                };
            }
        """)

        self.page = await self.context.new_page()

        return self.page

    def _get_stealth_args(self):
        return [
            '--disable-blink-features=AutomationControlled',
            '--disable-dev-shm-usage',
            '--disable-background-timer-throttling',
            '--disable-backgrounding-occluded-windows',
            '--disable-renderer-backgrounding',
            '--disable-features=IsolateOrigins,site-per-process',
            '--disable-web-security',
            '--disable-features=VizDisplayCompositor',
            '--start-maximized',
            '--no-sandbox',
            '--disable-setuid-sandbox',
            '--disable-infobars',
            '--window-position=0,0',
            '--ignore-certifcate-errors',
            '--ignore-ssl-errors',
            '--ignore-certificate-errors-spki-list',
        ]

    def _get_browser_channel(self):
        """Use installed Chrome instead of bundled Chromium"""
        import os
        chrome_paths = [
            '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',  # macOS
            'C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe',  # Windows
            '/usr/bin/google-chrome',  # Linux
        ]
        for path in chrome_paths:
            if os.path.exists(path):
                return 'chrome'
        return None  # Fall back to chromium

# Usage
async def main():
    browser = StealthBrowser()
    page = await browser.start()

    # Navigate with human-like behavior
    await human_like_navigate(page, 'https://example.com')

    await asyncio.sleep(300)  # Keep alive for debugging

asyncio.run(main())

import requests
import base64

async def bypass_cloudflare_turnstile(page, url):
    """
    Bypass Cloudflare Turnstile CAPTCHA using 2Captcha
    """

    # Navigate to page
    await page.goto(url, wait_until='networkidle')

    # Check if Turnstile is present
    turnstile_present = await page.query_selector('.cf-turnstile')
    if not turnstile_present:
        return True  # No CAPTCHA needed

    # Get site key
    site_key = await page.evaluate('''() => {
        const elem = document.querySelector('[data-sitekey]');
        return elem ? elem.getAttribute('data-sitekey') : null;
    }''')

    if not site_key:
        return False

    # Solve CAPTCHA using 2Captcha
    api_key = 'YOUR_2CAPTCHA_API_KEY'

    # Submit CAPTCHA
    submit_url = 'http://2captcha.com/in.php'
    submit_data = {
        'key': api_key,
        'method': 'turnstile',
        'sitekey': site_key,
        'pageurl': url,
        'json': 1
    }

    response = requests.post(submit_url, data=submit_data)
    result = response.json()

    if result['status'] != 1:
        raise Exception(f"Failed to submit CAPTCHA: {result}")

    captcha_id = result['request']

    # Wait for solution
    import time
    for _ in range(60):  # Wait up to 60 seconds
        await asyncio.sleep(3)

        result_url = f'http://2captcha.com/res.php?key={api_key}&action=get&id={captcha_id}&json=1'
        response = requests.get(result_url)
        result = response.json()

        if result['status'] == 1:
            token = result['request']

            # Inject token
            await page.evaluate('''(token) => {
                const textarea = document.querySelector('[name="cf-turnstile-response"]');
                if (textarea) {
                    textarea.value = token;
                    // Trigger change event
                    textarea.dispatchEvent(new Event('change', { bubbles: true }));
                }
            }''', token)

            # Submit form
            submit_button = await page.query_selector('button[type="submit"], input[type="submit"]')
            if submit_button:
                await submit_button.click()

            return True

    raise Exception("CAPTCHA solving timeout")

# Alternative: Use YesCAPTCHA (faster, more expensive)
async def solve_with_yescaptcha(page, url):
    """
    YesCAPTCHA has better success rate for Cloudflare
    """
    api_key = 'YESCAPTCHA_API_KEY'

    # Get challenge
    site_key = await page.evaluate('''() => {
        const elem = document.querySelector('[data-sitekey]');
        return elem ? elem.getAttribute('data-sitekey') : null;
    }''')

    # Submit to YesCAPTCHA
    submit_data = {
        'clientKey': api_key,
        'task': {
            'type': 'TurnstileTaskProxyless',
            'websiteURL': url,
            'websiteKey': site_key,
        }
    }

    response = requests.post(
        'https://api.yescaptcha.com/createTask',
        json=submit_data
    )
    result = response.json()

    task_id = result['taskId']

    # Poll for result
    while True:
        await asyncio.sleep(2)

        response = requests.post(
            'https://api.yescaptcha.com/getTaskResult',
            json={
                'clientKey': api_key,
                'taskId': task_id
            }
        )
        result = response.json()

        if result['status'] == 'ready':
            token = result['solution']['token']

            # Inject and submit
            await page.evaluate('''(token) => {
                document.querySelector('[name="cf-turnstile-response"]').value = token;
            }''', token)

            await page.click('button[type="submit"]')
            return True

import random
import asyncio
from scipy.stats import truncnorm

async def human_like_type(page, selector, text, delay_range=(50, 200)):
    """
    Type text like a human: variable delays, typos, corrections
    """
    element = await page.query_selector(selector)
    await element.click()

    for char in text:
        # Variable delay between keystrokes
        delay = random.gauss(delay_range[0], 30)
        delay = max(30, min(delay, 500))  # Clamp to reasonable range
        await asyncio.sleep(delay / 1000)

        # Occasional typo (5% chance)
        if random.random() < 0.05:
            wrong_char = random.choice('abcdefghijklmnopqrstuvwxyz')
            await element.type(wrong_char)
            await asyncio.sleep(random.uniform(0.1, 0.3))
            # Backspace
            await element.press('Backspace')
            await asyncio.sleep(random.uniform(0.1, 0.2))

        await element.type(char)

async def human_like_mouse_move(page, target_element):
    """
    Move mouse with natural Bezier curves
    """
    box = await target_element.bounding_box()

    # Generate random points
    start_x, start_y = await page.mouse.position
    end_x = box['x'] + box['width'] / 2
    end_y = box['y'] + box['height'] / 2

    # Bezier curve control points
    cp1_x = start_x + random.uniform(-100, 100)
    cp1_y = start_y + random.uniform(-100, 100)
    cp2_x = end_x + random.uniform(-50, 50)
    cp2_y = end_y + random.uniform(-50, 50)

    # Move through Bezier curve
    steps = 50
    for i in range(steps + 1):
        t = i / steps
        # Cubic Bezier formula
        x = (1-t)**3 * start_x + \
            3 * (1-t)**2 * t * cp1_x + \
            3 * (1-t) * t**2 * cp2_x + \
            t**3 * end_x
        y = (1-t)**3 * start_y + \
            3 * (1-t)**2 * t * cp1_y + \
            3 * (1-t) * t**2 * cp2_y + \
            t**3 * end_y

        await page.mouse.move(x, y)
        await asyncio.sleep(0.01)  # 10ms per step

async def human_like_scroll(page, target_position):
    """
    Scroll naturally with momentum and overshoot
    """
    current_position = await page.evaluate('window.pageYOffset')

    # Scroll in bursts
    while abs(current_position - target_position) > 50:
        # Random scroll distance
        scroll_amount = random.randint(100, 300)
        if target_position < current_position:
            scroll_amount = -scroll_amount

        # Scroll
        await page.evaluate(f'window.scrollBy(0, {scroll_amount})')

        # Pause
        await asyncio.sleep(random.uniform(0.3, 0.8))

        # Occasional overshoot correction
        if random.random() < 0.2:
            await page.evaluate(f'window.scrollBy(0, {-scroll_amount * 0.1})')
            await asyncio.sleep(0.2)

        current_position = await page.evaluate('window.pageYOffset')

async def human_like_navigate(page, url):
    """
    Navigate with human-like behavior patterns
    """
    # Load page
    await page.goto(url, wait_until='domcontentloaded')

    # Wait random time (reading)
    await asyncio.sleep(random.uniform(1, 3))

    # Scroll down
    await human_like_scroll(page, random.randint(500, 1500))

    # Wait more (reading content)
    await asyncio.sleep(random.uniform(2, 5))

    # Move mouse (like looking at something)
    if random.random() < 0.3:
        elements = await page.query_selector_all('a, button')
        if elements:
            await human_like_mouse_move(page, random.choice(elements))

    # Scroll more
    await human_like_scroll(page, random.randint(1000, 3000))