Manejo de CAPTCHA del dramaturgo con CaptchaAI (guía completa)

Playwright proporciona automatización confiable del navegador en Chromium, Firefox y WebKit. Cuando las páginas de destino ofrecen CAPTCHA, CaptchaAI los resuelve en el lado del servidor mientras Playwright maneja la interacción del navegador.

Requisitos

Requisito	Detalles
pitón	`pip install playwright requests` luego `playwright install`
Nodo.js	`npm install playwright axios`
Clave API CaptchaAI	Decaptchaai.com

Python: Dramaturgo + CaptchaAI

Configuración

from playwright.sync_api import sync_playwright
import requests
import time

API_KEY = "YOUR_API_KEY"

def solve_recaptcha(site_key, page_url):
    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY,
        "method": "userrecaptcha",
        "googlekey": site_key,
        "pageurl": page_url
    })
    if not resp.text.startswith("OK|"):
        raise Exception(resp.text)
    task_id = resp.text.split("|")[1]

    for _ in range(60):
        time.sleep(5)
        result = requests.get("https://ocr.captchaai.com/res.php", params={
            "key": API_KEY, "action": "get", "id": task_id
        })
        if result.text == "CAPCHA_NOT_READY": continue
        if result.text.startswith("OK|"): return result.text.split("|")[1]
        raise Exception(result.text)
    raise TimeoutError()

Ejemplo completo

def login_with_captcha(url, username, password):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        context = browser.new_context(
            user_agent="Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
        )
        page = context.new_page()
        page.goto(url)

        # Fill login form
        page.fill("#username", username)
        page.fill("#password", password)

        # Check for reCAPTCHA
        recaptcha = page.query_selector(".g-recaptcha")
        if recaptcha:
            site_key = recaptcha.get_attribute("data-sitekey")
            print(f"Solving reCAPTCHA: {site_key}")

            token = solve_recaptcha(site_key, page.url)

            # Inject token
            page.evaluate(f"""
                document.getElementById('g-recaptcha-response').innerHTML = '{token}';
                document.getElementById('g-recaptcha-response').style.display = '';
            """)

        # Submit
        page.click('button[type="submit"]')
        page.wait_for_load_state("networkidle")

        print(f"Current URL: {page.url}")
        content = page.content()

        browser.close()
        return content

result = login_with_captcha(
    "https://staging.example.com/qa-login",
    "user@example.com",
    "password123"
)

Versión asíncrona

from playwright.async_api import async_playwright
import aiohttp
import asyncio

async def solve_recaptcha_async(site_key, page_url):
    async with aiohttp.ClientSession() as session:
        params = {
            "key": API_KEY, "method": "userrecaptcha",
            "googlekey": site_key, "pageurl": page_url
        }
        async with session.get("https://ocr.captchaai.com/in.php", params=params) as resp:
            text = await resp.text()
            task_id = text.split("|")[1]

        for _ in range(60):
            await asyncio.sleep(5)
            params = {"key": API_KEY, "action": "get", "id": task_id}
            async with session.get("https://ocr.captchaai.com/res.php", params=params) as resp:
                text = await resp.text()
                if text == "CAPCHA_NOT_READY": continue
                if text.startswith("OK|"): return text.split("|")[1]
                raise Exception(text)
        raise TimeoutError()

async def main():
    async with async_playwright() as p:
        browser = await p.chromium.launch(headless=True)
        page = await browser.new_page()
        await page.goto("https://example.com/form")

        site_key = await page.get_attribute(".g-recaptcha", "data-sitekey")
        token = await solve_recaptcha_async(site_key, page.url)

        await page.evaluate(f"document.getElementById('g-recaptcha-response').innerHTML = '{token}'")
        await page.click('button[type="submit"]')
        await browser.close()

asyncio.run(main())

Node.js: Dramaturgo + CaptchaAI

const { chromium } = require("playwright");
const axios = require("axios");

const API_KEY = "YOUR_API_KEY";

async function solveRecaptcha(siteKey, pageUrl) {
  const submit = await axios.get("https://ocr.captchaai.com/in.php", {
    params: {
      key: API_KEY,
      method: "userrecaptcha",
      googlekey: siteKey,
      pageurl: pageUrl,
    },
  });
  const taskId = submit.data.split("|")[1];

  while (true) {
    await new Promise((r) => setTimeout(r, 5000));
    const result = await axios.get("https://ocr.captchaai.com/res.php", {
      params: { key: API_KEY, action: "get", id: taskId },
    });
    if (result.data === "CAPCHA_NOT_READY") continue;
    if (result.data.startsWith("OK|")) return result.data.split("|")[1];
    throw new Error(result.data);
  }
}

(async () => {
  const browser = await chromium.launch({ headless: true });
  const page = await browser.newPage();
  await page.goto("https://staging.example.com/qa-login");

  // Fill form
  await page.fill("#username", "user@example.com");
  await page.fill("#password", "password123");

  // Solve CAPTCHA
  const siteKey = await page.getAttribute(".g-recaptcha", "data-sitekey");
  if (siteKey) {
    const token = await solveRecaptcha(siteKey, page.url());
    await page.evaluate(
      (t) => (document.getElementById("g-recaptcha-response").innerHTML = t),
      token
    );
  }

  // Submit
  await page.click('button[type="submit"]');
  await page.waitForLoadState("networkidle");

  console.log("Logged in:", page.url());
  await browser.close();
})();

Manejo de Cloudflare Turnstile

# Detect Turnstile
turnstile = page.query_selector(".cf-turnstile")
if turnstile:
    site_key = turnstile.get_attribute("data-sitekey")

    resp = requests.get("https://ocr.captchaai.com/in.php", params={
        "key": API_KEY, "method": "turnstile",
        "sitekey": site_key, "pageurl": page.url
    })
    task_id = resp.text.split("|")[1]

    # Poll and inject...

Dramaturgo vs Selenio vs Puppeteer

Característica	dramaturgo	selenio	titiritero
Idiomas	Python, Node.js, C#, Java	Python, Java, C#, Rubí, JS	Nodo.js
Navegadores	Cromo, Firefox, WebKit	Chrome, Firefox, Borde, Safari	cromo
espera automática	✅ Incorporado	⏳ Esperas manuales	⚠️ Parcial
Intercepción de red	“…	⚠️ Limitado	“…
Integración CaptchaAI	“… Misma API	“… Misma API	“… Misma API

CaptchaAI funciona de manera idéntica con los tres: extrae la clave del sitio, resuelve mediante API e inyecta el token.

Solución de problemas

Problema	Solución
`page.query_selector` devuelve nulo	CAPTCHA se carga dinámicamente; utilizar `page.wait_for_selector()`
La inyección de token no funciona	Compruebe si el área de texto de respuesta tiene una ID diferente
El dramaturgo se bloquea en Docker	Instalar dependencias del navegador: `playwright install-deps`
CAPTCHA reaparece después de resolver	El sitio puede requerir la ejecución de una devolución de llamada; activarlo a través de `page.evaluate()`

Preguntas frecuentes

¿La espera automática de Playwright ayuda con los CAPTCHA?

La espera automática de Playwright garantiza que los elementos sean visibles antes de interactuar, pero no resolverá los CAPTCHA. Necesita CaptchaAI para la resolución real.

¿Puedo usar Playwright con todos los tipos de CAPTCHA?

Sí. CaptchaAI maneja la resolución a través de API: Playwright solo necesita extraer la clave del sitio e inyectar el token. Esto funciona para reCAPTCHA, Turnstile, hCaptcha y todos los demás tipos compatibles.

¿Playwright es mejor que Selenium para la automatización de CAPTCHA?

La espera automática integrada de Playwright y un mejor diseño de API hacen que los flujos de trabajo CAPTCHA sean más confiables. La integración CaptchaAI es idéntica para ambos.

Guías relacionadas

Manejo de Selenium CAPTCHA con Python
Puppeteer CAPTCHA Resolviendo con Node.js
Manejo automatizado de CAPTCHA de inicio de sesión

Manejo de CAPTCHA del dramaturgo con CaptchaAI