import requests
import time

API_KEY = "YOUR_CAPSOLVER_API_KEY"

def solve_captcha(site_key, url):
    # Crea una tarea de Capsolver
    create_task = {
        "clientKey": API_KEY,
        "task": {
            "type": "ReCaptchaV2TaskProxyless",
            "websiteURL": url,
            "websiteKey": site_key,
        }
    }
    
    resp = requests.post("https://api.capsolver.com/createTask", json=create_task)
    task_id = resp.json().get("taskId")
    
    if not task_id:
        raise RuntimeError("Error al crear la tarea de CapSolver")
    
    # Consulta el resultado
    while True:
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": API_KEY, "taskId": task_id}
        )
        payload = result.json()
        if payload.get("status") == "ready":
            return payload["solution"]["gRecaptchaResponse"]
        
        time.sleep(2)

pip install selenium playwright pyppeteer requests python-dotenv

playwright install

CAPSOLVER_API_KEY
BROWSERSTACK_USERNAME
BROWSERSTACK_ACCESS_KEY

import time
import os
import requests
from selenium import webdriver
from selenium.webdriver.common.by import By
from selenium.webdriver.chrome.options import Options
from dotenv import load_dotenv

# Carga las variables de entorno
load_dotenv()
API_KEY = os.getenv("CAPSOLVER_API_KEY")
BROWSERSTACK_USERNAME = os.getenv("BROWSERSTACK_USERNAME")
BROWSERSTACK_ACCESS_KEY = os.getenv("BROWSERSTACK_ACCESS_KEY")

def solve_captcha(site_key, url):
    """Crea una tarea de CapSolver y consulta el token de solución."""
    create_task = {
        "clientKey": API_KEY,
        "task": {
            "type": "ReCaptchaV2TaskProxyless",
            "websiteURL": url,
            "websiteKey": site_key,
        }
    }

    print(f"Creando tarea con API_KEY: {API_KEY[:10]}...")
    print(f"Clave del sitio: {site_key}")
    print(f"URL: {url}")

    resp = requests.post("https://api.capsolver.com/createTask", json=create_task)
    print(f"Estado de la respuesta: {resp.status_code}")
    print(f"Texto de la respuesta: {resp.text}")
    resp.raise_for_status()
    task_id = resp.json().get("taskId")

    if not task_id:
        raise RuntimeError("Error al crear la tarea de CapSolver")

    while True:
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": API_KEY, "taskId": task_id}
        )
        print(f"Estado del resultado de la tarea: {result.status_code}")
        print(f"Respuesta del resultado de la tarea: {result.text}")
        result.raise_for_status()
        payload = result.json()

        if payload.get("status") == "ready":
            return payload["solution"]["gRecaptchaResponse"]

        time.sleep(2)

def main():
    if not BROWSERSTACK_USERNAME or not BROWSERSTACK_ACCESS_KEY:
        raise SystemExit("Por favor, establece las variables de entorno BROWSERSTACK_USERNAME y BROWSERSTACK_ACCESS_KEY")

    # Capacidades de BrowserStack
    bstack_options = {
        "os": "Windows",
        "osVersion": "11",
        "buildName": "Prueba de Capsolver",
        "sessionName": "Resolver CAPTCHA",
        "local": "false",
        "debug": "true",
        "video": "true",
        "networkLogs": "true",
    }

    options = Options()
    options.set_capability("browserName", "Chrome")
    options.set_capability("browserVersion", "latest")
    options.set_capability("bstack:options", bstack_options)

    hub_url = f"https://{BROWSERSTACK_USERNAME}:{BROWSERSTACK_ACCESS_KEY}@hub-cloud.browserstack.com/wd/hub"
    driver = webdriver.Remote(command_executor=hub_url, options=options)

    # Imprime información de la sesión para observación en vivo
    print(f"ID de sesión de BrowserStack: {driver.session_id}")
    print("Observa en vivo en: https://automate.browserstack.com/dashboard/v2/builds")

    try:
        url = "https://www.google.com/recaptcha/api2/demo"
        driver.get(url)

        site_key = driver.find_element(By.CLASS_NAME, "g-recaptcha").get_attribute("data-sitekey")
        token = solve_captcha(site_key, url)

        # Haz que el área de texto de respuesta sea visible y establece el token
        driver.execute_script('document.getElementById("g-recaptcha-response").style.display = "block";')
        driver.execute_script(f'document.getElementById("g-recaptcha-response").value = "{token}";')
        driver.find_element(By.ID, "recaptcha-demo-submit").click()

        time.sleep(3)  # Espera a que se cargue la página

        # Inspecciona la página después del envío
        print("=" * 50)
        print("RESPUESTA DE LA PÁGINA DESPUÉS DEL ENVÍO:")
        print("=" * 50)
        print(f"URL actual: {driver.current_url}")
        print(f"Título de la página: {driver.title}")

        page_source = driver.page_source
        print(f"Longitud de la fuente de la página: {len(page_source)} caracteres")

        # Verifica si hay indicadores de éxito o error
        if any(word in page_source.lower() for word in ['success', 'verificado', 'genial', 'hooray']):
            print("✅ Indicador de ÉXITO encontrado en la página!")
        if "error" in page_source.lower():
            print("❌ Indicador de ERROR encontrado en la página!")
        if "captcha" in page_source.lower():
            print("🔄 CAPTCHA aún presente en la página")

        # Vista previa de los primeros 500 caracteres del texto del cuerpo
        try:
            body = driver.find_element(By.TAG_NAME, "body")
            print(f"Vista previa del texto del cuerpo:\n{body.text[:500]}")
        except Exception:
            print("No se pudo extraer el texto del cuerpo")

        print("=" * 50)
        time.sleep(2)

    finally:
        driver.quit()

if __name__ == "__main__":
    main()

import time
import os
import requests
import asyncio
import json
from playwright.async_api import async_playwright
from dotenv import load_dotenv

# Carga las variables de entorno
load_dotenv()
API_KEY = os.getenv("CAPSOLVER_API_KEY")
BROWSERSTACK_USERNAME = os.getenv("BROWSERSTACK_USERNAME")
BROWSERSTACK_ACCESS_KEY = os.getenv("BROWSERSTACK_ACCESS_KEY")

def solve_captcha(site_key, url):
    """
    Crea una tarea de CapSolver y consulta un token de solución.
    Funciona igual que el ejemplo de Selenium.
    """
    create_task = {
        "clientKey": API_KEY,
        "task": {
            "type": "ReCaptchaV2TaskProxyless",
            "websiteURL": url,
            "websiteKey": site_key,
        }
    }

    print(f"Creando tarea con API_KEY: {API_KEY[:10]}...")
    print(f"Clave del sitio: {site_key}")
    print(f"URL: {url}")

    resp = requests.post("https://api.capsolver.com/createTask", json=create_task)
    print(f"Estado de la respuesta: {resp.status_code}")
    print(f"Texto de la respuesta: {resp.text}")
    resp.raise_for_status()
    task_id = resp.json().get("taskId")

    if not task_id:
        raise RuntimeError("Error al crear la tarea de CapSolver")

    # Consulta hasta que la solución esté lista
    while True:
        result = requests.post(
            "https://api.capsolver.com/getTaskResult",
            json={"clientKey": API_KEY, "taskId": task_id}
        )
        result.raise_for_status()
        payload = result.json()
        if payload.get("status") == "ready":
            return payload["solution"]["gRecaptchaResponse"]
        time.sleep(2)

async def run_captcha_test(platform_config):
    """Ejecuta la prueba de CAPTCHA en una configuración de plataforma específica a través de BrowserStack."""
    print(f"\n🚀 Probando en: {platform_config['name']}")
    async with async_playwright() as playwright:
        # Conéctate a BrowserStack usando el punto final de CDP
        ws_endpoint = f"wss://cdp.browserstack.com/playwright?caps={platform_config['caps_string']}"
        try:
            browser = await playwright.chromium.connect_over_cdp(ws_endpoint)
            context = await browser.new_context(viewport={'width': 1280, 'height': 720})
            page = await context.new_page()
            
            print(f"✅ Conectado a BrowserStack")
            print("🔗 Observa en vivo en: https://automate.browserstack.com/dashboard/v2/builds")
            
            # Navega a la página de demostración de reCAPTCHA
            url = "https://www.google.com/recaptcha/api2/demo"
            await page.goto(url, wait_until="domcontentloaded", timeout=30000)
            await page.wait_for_selector(".g-recaptcha", timeout=20000)
            site_key = await page.get_attribute(".g-recaptcha", "data-sitekey")
            
            print(f"🔑 Clave del sitio encontrada: {site_key}")
            print("\n🧩 Resolviendo CAPTCHA con CapSolver...")
            token = solve_captcha(site_key, url)
            print(f"✅ Token de CAPTCHA obtenido: {token[:50]}...")
            
            # Inyecta el token y envía el formulario
            await page.evaluate('document.getElementById("g-recaptcha-response").style.display = "block";')
            await page.evaluate(f'document.getElementById("g-recaptcha-response").value = "{token}";')
            await page.click("#recaptcha-demo-submit")
            await page.wait_for_timeout(5000)

        current_url = page.url
        page_title = await page.title()
        body_text = await page.text_content("body")
        
        success_indicators = ['success', 'verificado', 'genial', 'hooray']
        is_success = any(word in body_text.lower() for word in success_indicators)
        has_error = 'error' in body_text.lower()
        has_captcha = 'captcha' in body_text.lower()
        
        print("\n" + "=" * 60)
        print(f"🎯 RESULTADOS PARA {platform_config['name']}:")
        print("=" * 60)
        print(f"📍 URL: {current_url}")
        print(f"📄 Título: {page_title}")
        print(f"🎉 Éxito: {'✅ SÍ' if is_success else '❌ NO'}")
        if has_error:
            print("❌ ¡Indicador de ERROR encontrado!")
        if has_captcha:
            print("🔄 ¡CAPTCHA aún presente!")
        print(f"\n📝 Vista previa de la página (primeros 500 caracteres):\n{'-'*40}\n{body_text[:500]}")
        print("=" * 60)
        
        await page.wait_for_timeout(3000)
        return {'platform': platform_config['name'], 'success': is_success, 'url': current_url, 'title': page_title}
    except Exception as e:
        print(f"❌ Error en {platform_config['name']}: {str(e)}")
        return {'platform': platform_config['name'], 'success': False, 'error': str(e)}
    finally:
        try:
            await browser.close()
        except Exception as e:
            print(f"Advertencia: Error al cerrar el navegador: {e}")
            pass

platforms = [
    {'name': 'Windows 11 - Chrome', 'os': 'Windows', 'osVersion': '11', 'browserName': 'chrome', 'browserVersion': 'latest'},
    {'name': 'macOS Ventura - Chrome', 'os': 'OS X', 'osVersion': 'Ventura', 'browserName': 'chrome', 'browserVersion': 'latest'}
]

print("🚀 Iniciando la demo de Playwright + BrowserStack + CapSolver...")
results = []
for platform in platforms:
    try:
        caps, caps_string = create_browserstack_caps(platform)
        platform['caps'] = caps
        platform['caps_string'] = caps_string
        result = await run_captcha_test(platform)
        results.append(result)
        await asyncio.sleep(2)
    except Exception as e:
        print(f"❌ Error al probar {platform['name']}: {str(e)}")
        results.append({'platform': platform['name'], 'success': False, 'error': str(e)})

# Resumen
print("\n" + "🏆"*60)
print("RESUMEN FINAL - TODAS LAS PLATAFORMAS")
print("🏆"*60)
successful_platforms = [r['platform'] for r in results if r['success']]
failed_platforms = [r['platform'] for r in results if not r['success']]
for r in results:
    if r['success']:
        print(f"✅ {r['platform']}: ÉXITO")
    else:
        print(f"❌ {r['platform']}: FALLÓ - {r.get('error', 'Error desconocido')}")
print(f"\n📊 Tasa de éxito: {len(successful_platforms)}/{len(results)} plataformas")
print(f"⏰ Prueba completada a las: {time.strftime('%Y-%m-%d %H:%M:%S')}")
if successful_platforms:
    print(f"\n🎉 Plataformas exitosas: {', '.join(successful_platforms)}")
if failed_platforms:
    print(f"\n⚠️ Plataformas fallidas: {', '.join(failed_platforms)}")
print("🏆"*60)

print(f"⏰ Prueba completada a las: {time.strftime('%Y-%m-%d %H:%M:%S')}")

    if successful_platforms:
        print(f"\n🎉 Plataformas exitosas: {', '.join(successful_platforms)}")
    if failed_platforms:
        print(f"\n⚠️ Plataformas fallidas: {', '.join(failed_platforms)}")

    print("🏆"*60)
    print("\n💡 Nota: Esta demo utiliza pyppeteer (Python Puppeteer) con BrowserStack")
    print("   Para obtener mejores resultados, asegúrese de que su plan de BrowserStack admita conexiones CDP")


if __name__ == "__main__":
    asyncio.run(main())